Release 5.18.0

Co-authored-by: Dylan T. <dktapps@pmmp.io>
Co-authored-by: IvanCraft623 <ivancraft623@gmail.com>

.github/PULL_REQUEST_TEMPLATE.md

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

.github/dependabot.yml

@@ -3,7 +3,7 @@ updates:
 - package-ecosystem: composer
   directory: "/"
   schedule:
-    interval: daily
+    interval: weekly
     time: "10:00"
   open-pull-requests-limit: 10
   ignore:
@@ -12,6 +12,22 @@ updates:
       update-types:
         - "version-update:semver-major"
         - "version-update:semver-minor"
+  groups:
+    production-patch-updates:
+      dependency-type: production
+      patterns:
+        - "*"
+      update-types:
+        - "patch"
+    development-patch-updates:
+      dependency-type: development
+      patterns:
+        - "*"
+      update-types:
+        - "patch"
+    phpstan:
+      patterns:
+        - "phpstan/*"
 
 - package-ecosystem: gitsubmodule
   directory: "/"
@@ -21,4 +37,4 @@ updates:
 - package-ecosystem: github-actions
   directory: "/"
   schedule:
-    interval: daily
+    interval: weekly

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

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

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

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

.github/workflows/draft-release.yml

@@ -20,12 +20,12 @@ jobs:
           submodules: true
 
       - name: Setup PHP
-        uses: shivammathur/setup-php@2.27.1
+        uses: shivammathur/setup-php@2.31.1
         with:
           php-version: ${{ matrix.php-version }}
 
       - name: Restore Composer package cache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             ~/.cache/composer/files
@@ -76,19 +76,23 @@ jobs:
             ${{ steps.php-binary-url.outputs.PHP_BINARY_URL }} \
             > build_info.json
 
+      - name: Generate core permission doc for doc.pmmp.io
+        run: php tools/generate-permission-doc.php rst
+
       - name: Upload release artifacts
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: release_artifacts
           path: |
             ${{ github.workspace }}/PocketMine-MP.phar
             ${{ github.workspace }}/start.*
             ${{ github.workspace }}/build_info.json
+            ${{ github.workspace }}/core-permissions.rst
 
       - name: Create draft release
-        uses: ncipollo/release-action@v1.13.0
+        uses: ncipollo/release-action@v1.14.0
         with:
-          artifacts: ${{ github.workspace }}/PocketMine-MP.phar,${{ github.workspace }}/start.*,${{ github.workspace }}/build_info.json
+          artifacts: ${{ github.workspace }}/PocketMine-MP.phar,${{ github.workspace }}/start.*,${{ github.workspace }}/build_info.json,${{ github.workspace }}/core-permissions.rst
           commit: ${{ github.sha }}
           draft: true
           prerelease: ${{ steps.get-pm-version.outputs.PRERELEASE }}

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

@@ -0,0 +1,156 @@
+name: CI (all supported PHP versions)
+
+on:
+  workflow_call:
+    inputs:
+      php:
+        description: 'PHP version in X.Y format'
+        required: true
+        type: string
+
+      #these are parameterized to ease updating
+      pm-version-major:
+        description: 'PocketMine-MP major version'
+        default: 5
+        type: number
+      image:
+        description: 'Runner image to use'
+        default: 'ubuntu-20.04'
+        type: string
+
+jobs:
+  phpstan:
+    name: PHPStan analysis
+    runs-on: ${{ inputs.image }}
+
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@3.1.0
+        with:
+          php-version: ${{ inputs.php }}
+          install-path: "./bin"
+          pm-version-major: ${{ inputs.pm-version-major }}
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ inputs.php }}-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: composer install --prefer-dist --no-interaction
+
+      - name: Run PHPStan
+        run: ./vendor/bin/phpstan analyze --no-progress --memory-limit=2G
+
+  phpunit:
+    name: PHPUnit tests
+    runs-on: ${{ inputs.image }}
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@3.1.0
+        with:
+          php-version: ${{ inputs.php }}
+          install-path: "./bin"
+          pm-version-major: ${{ inputs.pm-version-major }}
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ inputs.php }}-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: composer install --prefer-dist --no-interaction
+
+      - name: Run PHPUnit tests
+        run: ./vendor/bin/phpunit --bootstrap vendor/autoload.php --fail-on-warning tests/phpunit
+
+  integration:
+    name: Integration tests
+    runs-on: ${{ inputs.image }}
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@3.1.0
+        with:
+          php-version: ${{ inputs.php }}
+          install-path: "./bin"
+          pm-version-major: ${{ inputs.pm-version-major }}
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ inputs.php }}-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: composer install --no-dev --prefer-dist --no-interaction
+
+      - name: Run integration tests
+        run: ./tests/travis.sh -t4
+
+  codegen:
+    name: Generated Code consistency checks
+    runs-on: ${{ inputs.image }}
+    strategy:
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup PHP
+        uses: pmmp/setup-php-action@3.1.0
+        with:
+          php-version: ${{ inputs.php }}
+          install-path: "./bin"
+          pm-version-major: ${{ inputs.pm-version-major }}
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ inputs.php }}-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: composer install --no-dev --prefer-dist --no-interaction
+
+      - name: Update generated code
+        run: composer update-codegen
+
+      - name: Verify code is unchanged
+        run: |
+          git diff
+          git diff --quiet

.github/workflows/main.yml

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

.github/workflows/support.yml

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

.gitignore

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

build/generate-biome-ids.php

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

build/generate-block-serializer-consts.php

@@ -102,6 +102,25 @@ function generateClassHeader(string $className) : string{
 	return <<<HEADER
 <?php
 
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
 declare(strict_types=1);
 
 namespace $namespace;

build/generate-build-info-json.php

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

build/generate-item-type-names.php

@@ -61,6 +61,25 @@ function generateItemIds(ItemTypeDictionary $dictionary, BlockItemIdMap $blockIt
 	fwrite($file, <<<'HEADER'
 <?php
 
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
 declare(strict_types=1);
 
 namespace pocketmine\data\bedrock\item;

build/server-phar-stub.php

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

build/server-phar.php

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

changelogs/4.26.md

@@ -0,0 +1,16 @@
+# 4.26.0
+Released 6th December 2023.
+
+**For Minecraft: Bedrock Edition 1.20.50**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.50.
+
+**Plugin compatibility:** Plugins for previous 4.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.20.50.
+- Removed support for older versions.

changelogs/5.10.md

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

changelogs/5.11.md

@@ -0,0 +1,45 @@
+# 5.11.0
+Released 7th February 2024.
+
+**For Minecraft: Bedrock Edition 1.20.60**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.60.
+
+**Plugin compatibility:** Plugins for previous 5.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe`  or `pocketmine\data` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.20.60.
+- Removed support for earlier versions.
+
+## Fixes
+- Fixed `tools/generate-item-upgrade-schema.php` not correctly handling items whose IDs were changed multiple times.
+- Fixed `ServerKiller` not working correctly in some cases (incorrectly handled wake-up conditions).
+- `ItemBlock`s of `Air` blocks are now always considered as "null" items regardless of count, and don't occupy inventory slots.
+
+## Internals
+- Restructured GitHub Actions CI workflows to make them easier to maintain (no need to update PHP versions in multiple places anymore).
+- GitHub Actions CodeStyle workflow now uses php-cs-fixer 3.49.x.
+- Dependabot updates are now processed weekly instead of daily.
+
+# 5.11.1
+Released 23rd February 2024.
+
+## Fixes
+- Fixed subchunk count calculation in `ChunkSerializer` for non-overworld dimension (useful for dimension plugins).
+- Harden options used for processing JSON data, particularly on the network, to close security issues.
+
+## Documentation
+- Fixed PHPStan signature for `Utils::cloneObjectArray()`.
+
+## Internals
+- Updated GitHub Actions versions to get rid of deprecation warnings.
+
+# 5.11.2
+Released 26th February 2024.
+
+## Fixes
+- Added extra checks for `BookEditPacket` handling.

changelogs/5.12.md

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

changelogs/5.13.md

@@ -0,0 +1,16 @@
+# 5.13.0
+Released 13th March 2024.
+
+**For Minecraft: Bedrock Edition 1.20.70**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.70.
+
+**Plugin compatibility:** Plugins for previous 5.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe`  or `pocketmine\data` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.20.70.
+- Removed support for earlier versions.

changelogs/5.14.md

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

changelogs/5.15.md

@@ -0,0 +1,16 @@
+# 5.15.0
+Released 25th April 2024.
+
+**For Minecraft: Bedrock Edition 1.20.80**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.80.
+
+**Plugin compatibility:** Plugins for previous 5.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe`  or `pocketmine\data` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.20.80.
+- Removed support for earlier versions.

changelogs/5.16.md

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

changelogs/5.17.md

@@ -0,0 +1,38 @@
+# 5.17.0
+Released 10th July 2024.
+
+**For Minecraft: Bedrock Edition 1.21.2**
+
+This is a support release for Minecraft: Bedrock Edition 1.21.2.
+
+**Plugin compatibility:** Plugins for previous 5.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe`  or `pocketmine\data` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.21.2.
+- Removed support for earlier versions.
+
+## API
+### `pocketmine\player`
+- The following methods have been added:
+  - `public function closeAllForms() : void` - closes the current viewing form and forms in queue.
+
+## Fixes
+- Bowl can now be used as fuel.
+- Bells always drops themselves even when using an incompatible tool.
+
+# 5.17.1
+Released 13th August 2024.
+
+## Documentation
+- Added a note about `BlockStateData::CURRENT_VERSION`.
+
+## Fixes
+- Fixed anvil placement rotation to match vanilla.
+- Fixed outdated `BedrockWorldData` version, this was preventing use newer worlds.
+
+## Internals
+- Dependabot: PHPStan and patch updates are now grouped into a single PR.

changelogs/5.18.md

@@ -0,0 +1,19 @@
+# 5.18.0
+Released 16th August 2024.
+
+**For Minecraft: Bedrock Edition 1.21.20**
+
+This is a support release for Minecraft: Bedrock Edition 1.21.20.
+
+**Plugin compatibility:** Plugins for previous 5.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe`  or `pocketmine\data` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.21.20.
+- Removed support for earlier versions.
+
+## Fixes
+- Use `VISIBLE_MOB_EFFECTS` actor metadata property to send effect bubbles, this fixes effect bubbles not showing

changelogs/5.9.md

@@ -0,0 +1,30 @@
+# 5.9.0
+Released 6th December 2023.
+
+**For Minecraft: Bedrock Edition 1.20.50**
+
+This is a support release for Minecraft: Bedrock Edition 1.20.50.
+
+**Plugin compatibility:** Plugins for previous 5.x versions will run unchanged on this release, unless they use internal APIs, reflection, or packages like the `pocketmine\network\mcpe`  or `pocketmine\data` namespace.
+Do not update plugin minimum API versions unless you need new features added in this release.
+
+**WARNING: If your plugin uses the `pocketmine\network\mcpe` namespace, you're not shielded by API change constraints.**
+Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you're using packets directly.
+
+## General
+- Added support for Minecraft: Bedrock Edition 1.20.50.
+- Removed support for older versions.
+
+## Fixes
+- Fixed `pitcher_plant` and `pitcher_pod` not being accepted by `StringToItemParser` (and therefore not being usable in commands).
+- Rotation of items in item frames in worlds from newer versions of Bedrock is now correctly loaded.
+- Fixed possible crash in block update sending if a chunk was unloaded during a previous chunk's block update syncing.
+- Fixed `AsyncTask::fetchLocal()` throwing an exception if `null` was stored in the local storage.
+
+## Documentation
+- `Server::prepareBatch()` is now correctly marked as `@internal`.
+- Updated documentation for `Server::prepareBatch()` to accurately reflect its behaviour.
+- Fixed incorrect path in doc comments of `EnumTrait` and `RegistryTrait`.
+
+## Internals
+- Added PHP 8.3 to the test matrix. This has not been thoroughly tested yet, so it should only be used for testing purposes.

composer.json

@@ -22,7 +22,7 @@
       "ext-openssl": "*",
       "ext-pcre": "*",
       "ext-phar": "*",
-      "ext-pmmpthread": "^6.0.7",
+      "ext-pmmpthread": "^6.1.0",
       "ext-reflection": "*",
       "ext-simplexml": "*",
       "ext-sockets": "*",
@@ -32,30 +32,30 @@
       "ext-zlib": ">=1.2.11",
       "composer-runtime-api": "^2.0",
       "adhocore/json-comment": "~1.2.0",
-      "pocketmine/netresearch-jsonmapper": "~v4.2.1000",
-      "pocketmine/bedrock-block-upgrade-schema": "~3.3.0+bedrock-1.20.40",
-      "pocketmine/bedrock-data": "~2.6.0+bedrock-1.20.40",
-      "pocketmine/bedrock-item-upgrade-schema": "~1.5.0+bedrock-1.20.30",
-      "pocketmine/bedrock-protocol": "~25.0.0+bedrock-1.20.40",
+      "pocketmine/netresearch-jsonmapper": "~v4.4.999",
+      "pocketmine/bedrock-block-upgrade-schema": "~4.3.0+bedrock-1.21.20",
+      "pocketmine/bedrock-data": "~2.12.0+bedrock-1.21.20",
+      "pocketmine/bedrock-item-upgrade-schema": "~1.11.0+bedrock-1.21.20",
+      "pocketmine/bedrock-protocol": "~33.0.0+bedrock-1.21.20",
       "pocketmine/binaryutils": "^0.2.1",
       "pocketmine/callback-validator": "^1.0.2",
       "pocketmine/color": "^0.3.0",
-      "pocketmine/errorhandler": "^0.6.0",
+      "pocketmine/errorhandler": "^0.7.0",
       "pocketmine/locale-data": "~2.19.0",
       "pocketmine/log": "^0.4.0",
       "pocketmine/math": "~1.0.0",
       "pocketmine/nbt": "~1.0.0",
-      "pocketmine/raklib": "^0.15.0",
-      "pocketmine/raklib-ipc": "^0.2.0",
+      "pocketmine/raklib": "~1.1.0",
+      "pocketmine/raklib-ipc": "~1.0.0",
       "pocketmine/snooze": "^0.5.0",
       "ramsey/uuid": "~4.7.0",
-      "symfony/filesystem": "~6.3.0"
+      "symfony/filesystem": "~6.4.0"
    },
    "require-dev": {
-      "phpstan/phpstan": "1.10.41",
+      "phpstan/phpstan": "1.11.10",
       "phpstan/phpstan-phpunit": "^1.1.0",
       "phpstan/phpstan-strict-rules": "^1.2.0",
-      "phpunit/phpunit": "~10.3.0 || ~10.2.0 || ~10.1.0"
+      "phpunit/phpunit": "^10.5.24"
    },
    "autoload": {
       "psr-4": {
@@ -83,11 +83,14 @@
          "@composer install --no-dev --classmap-authoritative --ignore-platform-reqs",
          "@php -dphar.readonly=0 build/server-phar.php"
       ],
-      "update-registry-annotations": [
+      "update-codegen": [
+         "@php build/generate-bedrockdata-path-consts.php",
+         "@php build/generate-biome-ids.php",
+         "@php build/generate-block-serializer-consts.php vendor/pocketmine/bedrock-data/canonical_block_states.nbt",
+         "@php build/generate-item-type-names.php vendor/pocketmine/bedrock-data/required_item_list.json",
+         "@php build/generate-known-translation-apis.php",
+         "@php build/generate-pocketmine-yml-property-consts.php",
          "@php build/generate-registry-annotations.php src"
-      ],
-      "update-translation-apis": [
-         "@php build/generate-known-translation-apis.php"
       ]
    }
 }

install-local-protocol.sh

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

resources/pocketmine.yml

@@ -85,10 +85,11 @@ network:
   batch-threshold: 256
   #Compression level used when sending batched packets. Higher = more CPU, less bandwidth usage
   compression-level: 6
-  #Max threads to use for packet compression. If disabled, compression will be done on the main thread.
-  #Set to 0 to disable, or "auto" to try to detect the number of available CPU cores.
-  #Higher values will allow using more CPU cores, but will also increase memory usage.
-  compression-threads: auto
+  #Use AsyncTasks for compression during the main game session. Increases latency, but may reduce main thread load
+  async-compression: false
+  #Threshold for async compression, in bytes. Only packets larger than this will be compressed asynchronously
+  #Due to large overhead of AsyncTask, async compression isn't worth it except for large packets
+  async-compression-threshold: 10000
   #Experimental. Use UPnP to automatically port forward
   upnp-forwarding: false
   #Maximum size in bytes of packets sent over the network (default 1492 bytes). Packets larger than this will be

src/BootstrapOptions.php

@@ -45,4 +45,8 @@ final class BootstrapOptions{
 	public const PLUGINS = "plugins";
 	/** Path to store and load server data */
 	public const DATA = "data";
+	/** Shows basic server version information and exits */
+	public const VERSION = "version";
+	/** Disables writing logs to server.log */
+	public const NO_LOG_FILE = "no-log-file";
 }

src/PocketMine.php

@@ -25,6 +25,7 @@ namespace pocketmine {
 
 	use Composer\InstalledVersions;
 	use pocketmine\errorhandler\ErrorToExceptionHandler;
+	use pocketmine\network\mcpe\protocol\ProtocolInfo;
 	use pocketmine\thread\ThreadManager;
 	use pocketmine\thread\ThreadSafeClassLoader;
 	use pocketmine\utils\Filesystem;
@@ -40,14 +41,17 @@ namespace pocketmine {
 	use function extension_loaded;
 	use function function_exists;
 	use function getcwd;
+	use function getopt;
 	use function is_dir;
 	use function mkdir;
 	use function phpversion;
 	use function preg_match;
 	use function preg_quote;
+	use function printf;
 	use function realpath;
 	use function version_compare;
 	use const DIRECTORY_SEPARATOR;
+	use const PHP_EOL;
 
 	require_once __DIR__ . '/VersionInfo.php';
 
@@ -120,8 +124,8 @@ namespace pocketmine {
 		}
 
 		if(($pmmpthread_version = phpversion("pmmpthread")) !== false){
-			if(version_compare($pmmpthread_version, "6.0.7") < 0 || version_compare($pmmpthread_version, "7.0.0") >= 0){
-				$messages[] = "pmmpthread ^6.0.7 is required, while you have $pmmpthread_version.";
+			if(version_compare($pmmpthread_version, "6.1.0") < 0 || version_compare($pmmpthread_version, "7.0.0") >= 0){
+				$messages[] = "pmmpthread ^6.1.0 is required, while you have $pmmpthread_version.";
 			}
 		}
 
@@ -166,7 +170,7 @@ namespace pocketmine {
 	 * @return void
 	 */
 	function emit_performance_warnings(\Logger $logger){
-		if(PHP_DEBUG !== 0){
+		if(ZEND_DEBUG_BUILD){
 			$logger->warning("This PHP binary was compiled in debug mode. This has a major impact on performance.");
 		}
 		if(extension_loaded("xdebug") && (!function_exists('xdebug_info') || count(xdebug_info('mode')) !== 0)){
@@ -273,6 +277,11 @@ JIT_WARNING
 
 		ErrorToExceptionHandler::set();
 
+		if(count(getopt("", [BootstrapOptions::VERSION])) > 0){
+			printf("%s %s (git hash %s) for Minecraft: Bedrock Edition %s\n", VersionInfo::NAME, VersionInfo::VERSION()->getFullVersion(true), VersionInfo::GIT_HASH(), ProtocolInfo::MINECRAFT_VERSION);
+			exit(0);
+		}
+
 		$cwd = Utils::assumeNotFalse(realpath(Utils::assumeNotFalse(getcwd())));
 		$dataPath = getopt_string(BootstrapOptions::DATA) ?? $cwd;
 		$pluginPath = getopt_string(BootstrapOptions::PLUGINS) ?? $cwd . DIRECTORY_SEPARATOR . "plugins";
@@ -308,7 +317,7 @@ JIT_WARNING
 		//Logger has a dependency on timezone
 		Timezone::init();
 
-		$opts = getopt("", [BootstrapOptions::NO_WIZARD, BootstrapOptions::ENABLE_ANSI, BootstrapOptions::DISABLE_ANSI]);
+		$opts = getopt("", [BootstrapOptions::NO_WIZARD, BootstrapOptions::ENABLE_ANSI, BootstrapOptions::DISABLE_ANSI, BootstrapOptions::NO_LOG_FILE]);
 		if(isset($opts[BootstrapOptions::ENABLE_ANSI])){
 			Terminal::init(true);
 		}elseif(isset($opts[BootstrapOptions::DISABLE_ANSI])){
@@ -316,8 +325,13 @@ JIT_WARNING
 		}else{
 			Terminal::init();
 		}
+		$logFile = isset($opts[BootstrapOptions::NO_LOG_FILE]) ? null : Path::join($dataPath, "server.log");
+
+		$logger = new MainLogger($logFile, Terminal::hasFormattingCodes(), "Server", new \DateTimeZone(Timezone::get()), false, Path::join($dataPath, "log_archive"));
+		if($logFile === null){
+			$logger->notice("Logging to file disabled. Ensure logs are collected by other means (e.g. Docker logs).");
+		}
 
-		$logger = new MainLogger(Path::join($dataPath, "server.log"), Terminal::hasFormattingCodes(), "Server", new \DateTimeZone(Timezone::get()));
 		\GlobalLogger::set($logger);
 
 		emit_performance_warnings($logger);

src/Server.php

@@ -50,8 +50,8 @@ use pocketmine\lang\LanguageNotFoundException;
 use pocketmine\lang\Translatable;
 use pocketmine\nbt\tag\CompoundTag;
 use pocketmine\network\mcpe\compression\CompressBatchPromise;
+use pocketmine\network\mcpe\compression\CompressBatchTask;
 use pocketmine\network\mcpe\compression\Compressor;
-use pocketmine\network\mcpe\compression\CompressorWorkerPool;
 use pocketmine\network\mcpe\compression\ZlibCompressor;
 use pocketmine\network\mcpe\convert\TypeConverter;
 use pocketmine\network\mcpe\encryption\EncryptionContext;
@@ -59,7 +59,7 @@ use pocketmine\network\mcpe\EntityEventBroadcaster;
 use pocketmine\network\mcpe\NetworkSession;
 use pocketmine\network\mcpe\PacketBroadcaster;
 use pocketmine\network\mcpe\protocol\ProtocolInfo;
-use pocketmine\network\mcpe\protocol\serializer\PacketSerializerContext;
+use pocketmine\network\mcpe\protocol\types\CompressionAlgorithm;
 use pocketmine\network\mcpe\raklib\RakLibInterface;
 use pocketmine\network\mcpe\StandardEntityEventBroadcaster;
 use pocketmine\network\mcpe\StandardPacketBroadcaster;
@@ -125,6 +125,7 @@ use Symfony\Component\Filesystem\Path;
 use function array_fill;
 use function array_sum;
 use function base64_encode;
+use function chr;
 use function cli_set_process_title;
 use function copy;
 use function count;
@@ -208,6 +209,8 @@ class Server{
 	private const TICKS_PER_TPS_OVERLOAD_WARNING = 5 * self::TARGET_TICKS_PER_SECOND;
 	private const TICKS_PER_STATS_REPORT = 300 * self::TARGET_TICKS_PER_SECOND;
 
+	private const DEFAULT_ASYNC_COMPRESSION_THRESHOLD = 10_000;
+
 	private static ?Server $instance = null;
 
 	private TimeTrackingSleeperHandler $tickSleeper;
@@ -265,13 +268,8 @@ class Server{
 	private bool $onlineMode = true;
 
 	private Network $network;
-
-	private int $networkCompressionThreads;
-	/**
-	 * @var CompressorWorkerPool[]
-	 * @phpstan-var array<int, CompressorWorkerPool>
-	 */
-	private array $networkCompressionThreadPools = [];
+	private bool $networkCompressionAsync = true;
+	private int $networkCompressionAsyncThreshold = self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD;
 
 	private Language $language;
 	private bool $forceLanguage = false;
@@ -740,7 +738,7 @@ class Server{
 	 * @return string[][]
 	 */
 	public function getCommandAliases() : array{
-		$section = $this->configGroup->getProperty(YmlServerProperties::ALIASES);
+		$section = $this->configGroup->getProperty(Yml::ALIASES);
 		$result = [];
 		if(is_array($section)){
 			foreach($section as $key => $value){
@@ -864,7 +862,7 @@ class Server{
 					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error1(VersionInfo::NAME)));
 					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error2()));
 					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error3()));
-					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error4(YmlServerProperties::SETTINGS_ENABLE_DEV_BUILDS)));
+					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error4(Yml::SETTINGS_ENABLE_DEV_BUILDS)));
 					$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error5("https://github.com/pmmp/PocketMine-MP/releases")));
 					$this->forceShutdownExit();
 
@@ -910,12 +908,11 @@ class Server{
 			}
 			ZlibCompressor::setInstance(new ZlibCompressor($netCompressionLevel, $netCompressionThreshold, ZlibCompressor::DEFAULT_MAX_DECOMPRESSION_SIZE));
 
-			$netCompressionThreads = $this->configGroup->getPropertyString(Yml::NETWORK_COMPRESSION_THREADS, "auto");
-			if($netCompressionThreads === "auto"){
-				$this->networkCompressionThreads = max(1, Utils::getCoreCount() - 2);
-			}else{
-				$this->networkCompressionThreads = max(0, (int) $netCompressionThreads);
-			}
+			$this->networkCompressionAsync = $this->configGroup->getPropertyBool(Yml::NETWORK_ASYNC_COMPRESSION, true);
+			$this->networkCompressionAsyncThreshold = max(
+				$this->configGroup->getPropertyInt(Yml::NETWORK_ASYNC_COMPRESSION_THRESHOLD, self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD),
+				$netCompressionThreshold ?? self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD
+			);
 
 			EncryptionContext::$ENABLED = $this->configGroup->getPropertyBool(Yml::NETWORK_ENABLE_ENCRYPTION, true);
 
@@ -1189,12 +1186,11 @@ class Server{
 		bool $useQuery,
 		PacketBroadcaster $packetBroadcaster,
 		EntityEventBroadcaster $entityEventBroadcaster,
-		PacketSerializerContext $packetSerializerContext,
 		TypeConverter $typeConverter
 	) : bool{
 		$prettyIp = $ipV6 ? "[$ip]" : $ip;
 		try{
-			$rakLibRegistered = $this->network->registerInterface(new RakLibInterface($this, $ip, $port, $ipV6, $packetBroadcaster, $entityEventBroadcaster, $packetSerializerContext, $typeConverter));
+			$rakLibRegistered = $this->network->registerInterface(new RakLibInterface($this, $ip, $port, $ipV6, $packetBroadcaster, $entityEventBroadcaster, $typeConverter));
 		}catch(NetworkInterfaceStartException $e){
 			$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_networkStartFailed(
 				$ip,
@@ -1221,15 +1217,14 @@ class Server{
 		$useQuery = $this->configGroup->getConfigBool(ServerProperties::ENABLE_QUERY, true);
 
 		$typeConverter = TypeConverter::getInstance();
-		$packetSerializerContext = new PacketSerializerContext($typeConverter->getItemTypeDictionary());
-		$packetBroadcaster = new StandardPacketBroadcaster($this, $packetSerializerContext);
+		$packetBroadcaster = new StandardPacketBroadcaster($this);
 		$entityEventBroadcaster = new StandardEntityEventBroadcaster($packetBroadcaster, $typeConverter);
 
 		if(
-			!$this->startupPrepareConnectableNetworkInterfaces($this->getIp(), $this->getPort(), false, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $packetSerializerContext, $typeConverter) ||
+			!$this->startupPrepareConnectableNetworkInterfaces($this->getIp(), $this->getPort(), false, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $typeConverter) ||
 			(
 				$this->configGroup->getConfigBool(ServerProperties::ENABLE_IPV6, true) &&
-				!$this->startupPrepareConnectableNetworkInterfaces($this->getIpV6(), $this->getPortV6(), true, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $packetSerializerContext, $typeConverter)
+				!$this->startupPrepareConnectableNetworkInterfaces($this->getIpV6(), $this->getPortV6(), true, $useQuery, $packetBroadcaster, $entityEventBroadcaster, $typeConverter)
 			)
 		){
 			return false;
@@ -1359,44 +1354,44 @@ class Server{
 		return count($recipients);
 	}
 
-	private function getNetworkCompressionWorkerPool(Compressor $compressor) : CompressorWorkerPool{
-		$compressorId = spl_object_id($compressor);
-		$workerPool = $this->networkCompressionThreadPools[$compressorId] ?? null;
-		if($workerPool === null){
-			$this->logger->debug("Creating new worker pool for compressor " . get_class($compressor) . "#" . $compressorId);
-			$workerPool = $this->networkCompressionThreadPools[$compressorId] = new CompressorWorkerPool($this->networkCompressionThreads, $compressor, $this->tickSleeper);
-		}
-
-		return $workerPool;
-	}
-
 	/**
 	 * @internal
-	 * Broadcasts a list of packets in a batch to a list of players
+	 * Promises to compress the given batch buffer using the selected compressor, optionally on a separate thread.
+	 *
+	 * If the buffer is smaller than the batch-threshold (usually 256), the buffer will be compressed at level 0 if supported
+	 * by the compressor. This means that the payload will be wrapped with the appropriate header and footer, but not
+	 * actually compressed.
+	 *
+	 * If the buffer is larger than the async-compression-threshold (usually 10,000), the buffer may be compressed in
+	 * a separate thread (if available).
 	 *
 	 * @param bool|null $sync Compression on the main thread (true) or workers (false). Default is automatic (null).
 	 */
-	public function prepareBatch(string $buffer, Compressor $compressor, ?bool $sync = null, ?TimingsHandler $timings = null) : CompressBatchPromise{
+	public function prepareBatch(string $buffer, Compressor $compressor, ?bool $sync = null, ?TimingsHandler $timings = null) : CompressBatchPromise|string{
 		$timings ??= Timings::$playerNetworkSendCompress;
 		try{
 			$timings->startTiming();
 
-			if($sync === null){
-				$threshold = $compressor->getCompressionThreshold();
-				$sync = $threshold === null || strlen($buffer) < $threshold;
-			}
+			$threshold = $compressor->getCompressionThreshold();
+			if($threshold === null || strlen($buffer) < $compressor->getCompressionThreshold()){
+				$compressionType = CompressionAlgorithm::NONE;
+				$compressed = $buffer;
 
-			if(!$sync && $this->networkCompressionThreads > 0){
-				$workerPool = $this->getNetworkCompressionWorkerPool($compressor);
-
-				//TODO: we really want to be submitting all sessions' buffers in one go to maximize performance
-				$promise = $workerPool->submit($buffer);
 			}else{
-				$promise = new CompressBatchPromise();
-				$promise->resolve($compressor->compress($buffer));
+				$sync ??= !$this->networkCompressionAsync;
+
+				if(!$sync && strlen($buffer) >= $this->networkCompressionAsyncThreshold){
+					$promise = new CompressBatchPromise();
+					$task = new CompressBatchTask($buffer, $promise, $compressor);
+					$this->asyncPool->submitTask($task);
+					return $promise;
+				}
+
+				$compressionType = $compressor->getNetworkId();
+				$compressed = $compressor->compress($buffer);
 			}
 
-			return $promise;
+			return chr($compressionType) . $compressed;
 		}finally{
 			$timings->stopTiming();
 		}
@@ -1478,7 +1473,7 @@ class Server{
 			}
 
 			if(isset($this->network)){
-				$this->network->getSessionManager()->close($this->configGroup->getPropertyString(YmlServerProperties::SETTINGS_SHUTDOWN_MESSAGE, "Server closed"));
+				$this->network->getSessionManager()->close($this->configGroup->getPropertyString(Yml::SETTINGS_SHUTDOWN_MESSAGE, "Server closed"));
 			}
 
 			if(isset($this->worldManager)){
@@ -1513,10 +1508,6 @@ class Server{
 					$this->network->unregisterInterface($interface);
 				}
 			}
-			foreach($this->networkCompressionThreadPools as $pool){
-				$this->logger->debug("Shutting down network compression thread pool for compressor " . get_class($pool->getCompressor()) . "#" . spl_object_id($pool->getCompressor()));
-				$pool->shutdown();
-			}
 		}catch(\Throwable $e){
 			$this->logger->logException($e);
 			$this->logger->emergency("Crashed while crashing, killing process");
@@ -1675,9 +1666,11 @@ class Server{
 		$this->isRunning = false;
 
 		//Force minimum uptime to be >= 120 seconds, to reduce the impact of spammy crash loops
-		$spacing = ((int) $this->startTime) - time() + 120;
+		$uptime = time() - ((int) $this->startTime);
+		$minUptime = 120;
+		$spacing = $minUptime - $uptime;
 		if($spacing > 0){
-			echo "--- Waiting $spacing seconds to throttle automatic restart (you can kill the process safely now) ---" . PHP_EOL;
+			echo "--- Uptime {$uptime}s - waiting {$spacing}s to throttle automatic restart (you can kill the process safely now) ---" . PHP_EOL;
 			sleep($spacing);
 		}
 		@Process::kill(Process::pid());

src/VersionInfo.php

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

src/YmlServerProperties.php

@@ -90,9 +90,10 @@ final class YmlServerProperties{
 	public const MEMORY_WORLD_CACHES_DISABLE_CHUNK_CACHE = 'memory.world-caches.disable-chunk-cache';
 	public const MEMORY_WORLD_CACHES_LOW_MEMORY_TRIGGER = 'memory.world-caches.low-memory-trigger';
 	public const NETWORK = 'network';
+	public const NETWORK_ASYNC_COMPRESSION = 'network.async-compression';
+	public const NETWORK_ASYNC_COMPRESSION_THRESHOLD = 'network.async-compression-threshold';
 	public const NETWORK_BATCH_THRESHOLD = 'network.batch-threshold';
 	public const NETWORK_COMPRESSION_LEVEL = 'network.compression-level';
-	public const NETWORK_COMPRESSION_THREADS = 'network.compression-threads';
 	public const NETWORK_ENABLE_ENCRYPTION = 'network.enable-encryption';
 	public const NETWORK_MAX_MTU_SIZE = 'network.max-mtu-size';
 	public const NETWORK_UPNP_FORWARDING = 'network.upnp-forwarding';

src/block/Anvil.php

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

src/block/BaseBanner.php

@@ -34,7 +34,6 @@ use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
-use function array_filter;
 use function assert;
 use function count;
 
@@ -89,11 +88,12 @@ abstract class BaseBanner extends Transparent{
 	 * @return $this
 	 */
 	public function setPatterns(array $patterns) : self{
-		$checked = array_filter($patterns, fn($v) => $v instanceof BannerPatternLayer);
-		if(count($checked) !== count($patterns)){
-			throw new \TypeError("Deque must only contain " . BannerPatternLayer::class . " objects");
+		foreach($patterns as $pattern){
+			if(!$pattern instanceof BannerPatternLayer){
+				throw new \TypeError("Array must only contain " . BannerPatternLayer::class . " objects");
+			}
 		}
-		$this->patterns = $checked;
+		$this->patterns = $patterns;
 		return $this;
 	}
 

src/block/Bell.php

@@ -150,6 +150,10 @@ final class Bell extends Transparent{
 		}
 	}
 
+	public function getDropsForIncompatibleTool(Item $item) : array{
+		return [$this->asItem()];
+	}
+
 	private function isValidFaceToRing(int $faceHit) : bool{
 		return match($this->attachmentType){
 			BellAttachmentType::CEILING => true,

src/block/Block.php

@@ -402,7 +402,7 @@ class Block{
 	}
 
 	/**
-	 * AKA: Block->isPlaceable
+	 * Returns whether this block can be placed when obtained as an item.
 	 */
 	public function canBePlaced() : bool{
 		return true;
@@ -572,16 +572,28 @@ class Block{
 		return $this->getLightFilter() > 0;
 	}
 
+	/**
+	 * Returns whether this block allows any light to pass through it.
+	 */
 	public function isTransparent() : bool{
 		return false;
 	}
 
+	/**
+	 * @deprecated TL;DR: Don't use this function. Its results are confusing and inconsistent.
+	 *
+	 * No one is sure what the meaning of this property actually is. It's borrowed from Minecraft Java Edition, and is
+	 * used by various blocks for support checks.
+	 *
+	 * Things like signs and banners are considered "solid" despite having no collision box, and things like skulls and
+	 * flower pots are considered non-solid despite obviously being "solid" in the conventional, real-world sense.
+	 */
 	public function isSolid() : bool{
 		return true;
 	}
 
 	/**
-	 * AKA: Block->isFlowable
+	 * Returns whether this block can be destroyed by liquid flowing into its cell.
 	 */
 	public function canBeFlowedInto() : bool{
 		return false;

src/block/CocoaBlock.php

@@ -26,7 +26,6 @@ namespace pocketmine\block;
 use pocketmine\block\utils\AgeableTrait;
 use pocketmine\block\utils\BlockEventHelper;
 use pocketmine\block\utils\HorizontalFacingTrait;
-use pocketmine\block\utils\SupportType;
 use pocketmine\block\utils\WoodType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Fertilizer;
@@ -40,7 +39,7 @@ use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
 use function mt_rand;
 
-class CocoaBlock extends Transparent{
+class CocoaBlock extends Flowable{
 	use HorizontalFacingTrait;
 	use AgeableTrait;
 
@@ -65,10 +64,6 @@ class CocoaBlock extends Transparent{
 		];
 	}
 
-	public function getSupportType(int $facing) : SupportType{
-		return SupportType::NONE;
-	}
-
 	private function canAttachTo(Block $block) : bool{
 		return $block instanceof Wood && $block->getWoodType() === WoodType::JUNGLE;
 	}

src/block/DoublePitcherCrop.php

@@ -29,6 +29,7 @@ use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\event\block\StructureGrowEvent;
 use pocketmine\item\Fertilizer;
 use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
 use pocketmine\math\Axis;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
@@ -106,4 +107,14 @@ final class DoublePitcherCrop extends DoublePlant{
 			$this->grow(null);
 		}
 	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [
+			$this->age >= self::MAX_AGE ? VanillaBlocks::PITCHER_PLANT()->asItem() : VanillaItems::PITCHER_POD()
+		];
+	}
+
+	public function asItem() : Item{
+		return VanillaItems::PITCHER_POD();
+	}
 }

src/block/Furnace.php

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

src/block/NetherRoots.php

@@ -34,6 +34,7 @@ final class NetherRoots extends Flowable{
 		$supportBlock = $block->getSide(Facing::DOWN);
 		return
 			$supportBlock->hasTypeTag(BlockTypeTags::DIRT) ||
-			$supportBlock->hasTypeTag(BlockTypeTags::MUD);
+			$supportBlock->hasTypeTag(BlockTypeTags::MUD) ||
+			$supportBlock->getTypeId() === BlockTypeIds::SOUL_SOIL;
 	}
 }

src/block/PitcherCrop.php

@@ -30,6 +30,7 @@ use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\event\block\StructureGrowEvent;
 use pocketmine\item\Fertilizer;
 use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
 use pocketmine\math\Axis;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
@@ -101,4 +102,8 @@ final class PitcherCrop extends Flowable{
 			$this->grow(null);
 		}
 	}
+
+	public function asItem() : Item{
+		return VanillaItems::PITCHER_POD();
+	}
 }

src/block/RedstoneOre.php

@@ -24,7 +24,7 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\FortuneDropHelper;
-use pocketmine\data\runtime\RuntimeDataDescriber;
+use pocketmine\block\utils\LightableTrait;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 use pocketmine\math\Vector3;
@@ -32,23 +32,7 @@ use pocketmine\player\Player;
 use function mt_rand;
 
 class RedstoneOre extends Opaque{
-	protected bool $lit = false;
-
-	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->bool($this->lit);
-	}
-
-	public function isLit() : bool{
-		return $this->lit;
-	}
-
-	/**
-	 * @return $this
-	 */
-	public function setLit(bool $lit = true) : self{
-		$this->lit = $lit;
-		return $this;
-	}
+	use LightableTrait;
 
 	public function getLightLevel() : int{
 		return $this->lit ? 9 : 0;

src/block/RedstoneTorch.php

@@ -23,28 +23,22 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\LightableTrait;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 
 class RedstoneTorch extends Torch{
-	protected bool $lit = true;
+	use LightableTrait;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
+		$this->lit = true;
+		parent::__construct($idInfo, $name, $typeInfo);
+	}
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
 		parent::describeBlockOnlyState($w);
 		$w->bool($this->lit);
 	}
 
-	public function isLit() : bool{
-		return $this->lit;
-	}
-
-	/**
-	 * @return $this
-	 */
-	public function setLit(bool $lit = true) : self{
-		$this->lit = $lit;
-		return $this;
-	}
-
 	public function getLightLevel() : int{
 		return $this->lit ? 7 : 0;
 	}

src/block/SweetBerryBush.php

@@ -36,6 +36,7 @@ use pocketmine\item\VanillaItems;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
+use pocketmine\world\sound\SweetBerriesPickSound;
 use function mt_rand;
 
 class SweetBerryBush extends Flowable{
@@ -81,6 +82,7 @@ class SweetBerryBush extends Flowable{
 		}elseif(($dropAmount = $this->getBerryDropAmount()) > 0){
 			$world->setBlock($this->position, $this->setAge(self::STAGE_BUSH_NO_BERRIES));
 			$world->dropItem($this->position, $this->asItem()->setCount($dropAmount));
+			$world->addSound($this->position, new SweetBerriesPickSound());
 		}
 
 		return true;

src/block/VanillaBlocks.php

@@ -788,7 +788,7 @@ final class VanillaBlocks{
 	}
 
 	protected static function setup() : void{
-		$railBreakInfo = new Info(new BlockBreakInfo(0.7));
+		$railBreakInfo = new Info(new BreakInfo(0.7));
 		self::register("activator_rail", new ActivatorRail(new BID(Ids::ACTIVATOR_RAIL), "Activator Rail", $railBreakInfo));
 		self::register("air", new Air(new BID(Ids::AIR), "Air", new Info(BreakInfo::indestructible(-1.0))));
 		self::register("anvil", new Anvil(new BID(Ids::ANVIL), "Anvil", new Info(BreakInfo::pickaxe(5.0, ToolTier::WOOD, 6000.0))));
@@ -1638,7 +1638,7 @@ final class VanillaBlocks{
 
 		self::register("cave_vines", new CaveVines(new BID(Ids::CAVE_VINES), "Cave Vines", new Info(BreakInfo::instant())));
 
-		self::register("small_dripleaf", new SmallDripleaf(new BID(Ids::SMALL_DRIPLEAF), "Small Dripleaf", new Info(BreakInfo::instant(BlockToolType::SHEARS, toolHarvestLevel: 1))));
+		self::register("small_dripleaf", new SmallDripleaf(new BID(Ids::SMALL_DRIPLEAF), "Small Dripleaf", new Info(BreakInfo::instant(ToolType::SHEARS, toolHarvestLevel: 1))));
 		self::register("big_dripleaf_head", new BigDripleafHead(new BID(Ids::BIG_DRIPLEAF_HEAD), "Big Dripleaf", new Info(BreakInfo::instant())));
 		self::register("big_dripleaf_stem", new BigDripleafStem(new BID(Ids::BIG_DRIPLEAF_STEM), "Big Dripleaf Stem", new Info(BreakInfo::instant())));
 	}

src/block/WoodLikeBlockIdHelper.php

@@ -171,7 +171,7 @@ final class WoodLikeBlockIdHelper{
 		};
 	}
 
-	public static function getTrapdoorIdentifier(WoodType $treeType) : BlockIdentifier{
+	public static function getTrapdoorIdentifier(WoodType $treeType) : BID{
 		return new BID(match($treeType){
 			WoodType::OAK => Ids::OAK_TRAPDOOR,
 			WoodType::SPRUCE => Ids::SPRUCE_TRAPDOOR,
@@ -186,7 +186,7 @@ final class WoodLikeBlockIdHelper{
 		});
 	}
 
-	public static function getButtonIdentifier(WoodType $treeType) : BlockIdentifier{
+	public static function getButtonIdentifier(WoodType $treeType) : BID{
 		return new BID(match($treeType){
 			WoodType::OAK => Ids::OAK_BUTTON,
 			WoodType::SPRUCE => Ids::SPRUCE_BUTTON,
@@ -201,7 +201,7 @@ final class WoodLikeBlockIdHelper{
 		});
 	}
 
-	public static function getPressurePlateIdentifier(WoodType $treeType) : BlockIdentifier{
+	public static function getPressurePlateIdentifier(WoodType $treeType) : BID{
 		return new BID(match($treeType){
 			WoodType::OAK => Ids::OAK_PRESSURE_PLATE,
 			WoodType::SPRUCE => Ids::SPRUCE_PRESSURE_PLATE,
@@ -216,7 +216,7 @@ final class WoodLikeBlockIdHelper{
 		});
 	}
 
-	public static function getDoorIdentifier(WoodType $treeType) : BlockIdentifier{
+	public static function getDoorIdentifier(WoodType $treeType) : BID{
 		return new BID(match($treeType){
 			WoodType::OAK => Ids::OAK_DOOR,
 			WoodType::SPRUCE => Ids::SPRUCE_DOOR,
@@ -231,7 +231,7 @@ final class WoodLikeBlockIdHelper{
 		});
 	}
 
-	public static function getFenceGateIdentifier(WoodType $treeType) : BlockIdentifier{
+	public static function getFenceGateIdentifier(WoodType $treeType) : BID{
 		return new BID(match($treeType){
 			WoodType::OAK => Ids::OAK_FENCE_GATE,
 			WoodType::SPRUCE => Ids::SPRUCE_FENCE_GATE,
@@ -246,7 +246,7 @@ final class WoodLikeBlockIdHelper{
 		});
 	}
 
-	public static function getStairsIdentifier(WoodType $treeType) : BlockIdentifier{
+	public static function getStairsIdentifier(WoodType $treeType) : BID{
 		return new BID(match($treeType){
 			WoodType::OAK => Ids::OAK_STAIRS,
 			WoodType::SPRUCE => Ids::SPRUCE_STAIRS,

src/block/WoodenStairs.php

@@ -28,6 +28,10 @@ use pocketmine\block\utils\WoodTypeTrait;
 class WoodenStairs extends Stair{
 	use WoodTypeTrait;
 
+	public function getFuelTime() : int{
+		return $this->woodType->isFlammable() ? 300 : 0;
+	}
+
 	public function getFlameEncouragement() : int{
 		return 5;
 	}

src/block/tile/ItemFrame.php

@@ -27,6 +27,7 @@ use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
 use pocketmine\math\Vector3;
 use pocketmine\nbt\tag\CompoundTag;
+use pocketmine\nbt\tag\FloatTag;
 use pocketmine\network\mcpe\convert\TypeConverter;
 use pocketmine\world\World;
 
@@ -52,13 +53,17 @@ class ItemFrame extends Spawnable{
 		if(($itemTag = $nbt->getCompoundTag(self::TAG_ITEM)) !== null){
 			$this->item = Item::nbtDeserialize($itemTag);
 		}
-		$this->itemRotation = $nbt->getByte(self::TAG_ITEM_ROTATION, $this->itemRotation);
+		if($nbt->getTag(self::TAG_ITEM_ROTATION) instanceof FloatTag){
+			$this->itemRotation = (int) ($nbt->getFloat(self::TAG_ITEM_ROTATION, $this->itemRotation * 45) / 45);
+		} else {
+			$this->itemRotation = $nbt->getByte(self::TAG_ITEM_ROTATION, $this->itemRotation);
+		}
 		$this->itemDropChance = $nbt->getFloat(self::TAG_ITEM_DROP_CHANCE, $this->itemDropChance);
 	}
 
 	protected function writeSaveData(CompoundTag $nbt) : void{
 		$nbt->setFloat(self::TAG_ITEM_DROP_CHANCE, $this->itemDropChance);
-		$nbt->setByte(self::TAG_ITEM_ROTATION, $this->itemRotation);
+		$nbt->setFloat(self::TAG_ITEM_ROTATION, $this->itemRotation * 45);
 		if(!$this->item->isNull()){
 			$nbt->setTag(self::TAG_ITEM, $this->item->nbtSerialize());
 		}
@@ -98,7 +103,7 @@ class ItemFrame extends Spawnable{
 
 	protected function addAdditionalSpawnData(CompoundTag $nbt) : void{
 		$nbt->setFloat(self::TAG_ITEM_DROP_CHANCE, $this->itemDropChance);
-		$nbt->setByte(self::TAG_ITEM_ROTATION, $this->itemRotation);
+		$nbt->setFloat(self::TAG_ITEM_ROTATION, $this->itemRotation * 45);
 		if(!$this->item->isNull()){
 			$nbt->setTag(self::TAG_ITEM, TypeConverter::getInstance()->getItemTranslator()->toNetworkNbt($this->item));
 		}

src/block/utils/BannerPatternType.php

@@ -82,6 +82,7 @@ enum BannerPatternType{
 	case DIAGONAL_UP_LEFT;
 	case DIAGONAL_UP_RIGHT;
 	case FLOWER;
+	case GLOBE;
 	case GRADIENT;
 	case GRADIENT_UP;
 	case HALF_HORIZONTAL;
@@ -89,6 +90,7 @@ enum BannerPatternType{
 	case HALF_VERTICAL;
 	case HALF_VERTICAL_RIGHT;
 	case MOJANG;
+	case PIGLIN;
 	case RHOMBUS;
 	case SKULL;
 	case SMALL_STRIPES;

src/block/utils/CandleTrait.php

@@ -24,7 +24,6 @@ declare(strict_types=1);
 namespace pocketmine\block\utils;
 
 use pocketmine\block\Block;
-use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\entity\projectile\Projectile;
 use pocketmine\item\Durable;
 use pocketmine\item\enchantment\VanillaEnchantments;
@@ -38,24 +37,12 @@ use pocketmine\world\sound\FireExtinguishSound;
 use pocketmine\world\sound\FlintSteelSound;
 
 trait CandleTrait{
-	private bool $lit = false;
-
-	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->bool($this->lit);
-	}
+	use LightableTrait;
 
 	public function getLightLevel() : int{
 		return $this->lit ? 3 : 0;
 	}
 
-	public function isLit() : bool{ return $this->lit; }
-
-	/** @return $this */
-	public function setLit(bool $lit) : self{
-		$this->lit = $lit;
-		return $this;
-	}
-
 	/** @see Block::onInteract() */
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($item->getTypeId() === ItemTypeIds::FIRE_CHARGE || $item->getTypeId() === ItemTypeIds::FLINT_AND_STEEL || $item->hasEnchantment(VanillaEnchantments::FIRE_ASPECT())){

src/block/utils/LightableTrait.php

@@ -0,0 +1,46 @@
+<?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\utils;
+
+use pocketmine\data\runtime\RuntimeDataDescriber;
+
+trait LightableTrait{
+	protected bool $lit = false;
+
+	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
+		$w->bool($this->lit);
+	}
+
+	public function isLit() : bool{
+		return $this->lit;
+	}
+
+	/**
+	 * @return $this
+	 */
+	public function setLit(bool $lit = true) : self{
+		$this->lit = $lit;
+		return $this;
+	}
+}

src/crafting/CraftingManagerFromDataHelper.php

@@ -236,6 +236,7 @@ final class CraftingManagerFromDataHelper{
 				}
 				$outputs[] = $output;
 			}
+			//TODO: check unlocking requirements - our current system doesn't support this
 			$result->registerShapelessRecipe(new ShapelessRecipe(
 				$inputs,
 				$outputs,
@@ -262,6 +263,7 @@ final class CraftingManagerFromDataHelper{
 				}
 				$outputs[] = $output;
 			}
+			//TODO: check unlocking requirements - our current system doesn't support this
 			$result->registerShapedRecipe(new ShapedRecipe(
 				$recipe->shape,
 				$inputs,

src/crafting/json/ShapedRecipeData.php

@@ -23,7 +23,9 @@ declare(strict_types=1);
 
 namespace pocketmine\crafting\json;
 
-final class ShapedRecipeData{
+use function count;
+
+final class ShapedRecipeData implements \JsonSerializable{
 	/**
 	 * @required
 	 * @var string[]
@@ -51,22 +53,39 @@ final class ShapedRecipeData{
 	/** @required */
 	public int $priority;
 
+	/** @var RecipeIngredientData[] */
+	public array $unlockingIngredients = [];
+
 	/**
 	 * TODO: convert this to use promoted properties - avoiding them for now since it would break JsonMapper
 	 *
 	 * @param string[]               $shape
 	 * @param RecipeIngredientData[] $input
 	 * @param ItemStackData[]        $output
+	 * @param RecipeIngredientData[] $unlockingIngredients
 	 *
 	 * @phpstan-param list<string> $shape
 	 * @phpstan-param array<string, RecipeIngredientData> $input
 	 * @phpstan-param list<ItemStackData> $output
+	 * @phpstan-param list<RecipeIngredientData> $unlockingIngredients
 	 */
-	public function __construct(array $shape, array $input, array $output, string $block, int $priority){
+	public function __construct(array $shape, array $input, array $output, string $block, int $priority, array $unlockingIngredients = []){
 		$this->block = $block;
 		$this->priority = $priority;
 		$this->shape = $shape;
 		$this->input = $input;
 		$this->output = $output;
+		$this->unlockingIngredients = $unlockingIngredients;
+	}
+
+	/**
+	 * @return mixed[]
+	 */
+	public function jsonSerialize() : array{
+		$result = (array) $this;
+		if(count($this->unlockingIngredients) === 0){
+			unset($result["unlockingIngredients"]);
+		}
+		return $result;
 	}
 }

src/crafting/json/ShapelessRecipeData.php

@@ -23,7 +23,9 @@ declare(strict_types=1);
 
 namespace pocketmine\crafting\json;
 
-final class ShapelessRecipeData{
+use function count;
+
+final class ShapelessRecipeData implements \JsonSerializable{
 
 	/**
 	 * @required
@@ -45,17 +47,34 @@ final class ShapelessRecipeData{
 	/** @required */
 	public int $priority;
 
+	/** @var RecipeIngredientData[] */
+	public array $unlockingIngredients = [];
+
 	/**
 	 * @param RecipeIngredientData[] $input
 	 * @param ItemStackData[]        $output
+	 * @param RecipeIngredientData[] $unlockingIngredients
 	 *
 	 * @phpstan-param list<RecipeIngredientData> $input
 	 * @phpstan-param list<ItemStackData> $output
+	 * @phpstan-param list<RecipeIngredientData> $unlockingIngredients
 	 */
-	public function __construct(array $input, array $output, string $block, int $priority){
+	public function __construct(array $input, array $output, string $block, int $priority, array $unlockingIngredients = []){
 		$this->block = $block;
 		$this->priority = $priority;
 		$this->input = $input;
 		$this->output = $output;
+		$this->unlockingIngredients = $unlockingIngredients;
+	}
+
+	/**
+	 * @return mixed[]
+	 */
+	public function jsonSerialize() : array{
+		$result = (array) $this;
+		if(count($this->unlockingIngredients) === 0){
+			unset($result["unlockingIngredients"]);
+		}
+		return $result;
 	}
 }

src/crash/CrashDump.php

@@ -63,6 +63,12 @@ use function strpos;
 use function substr;
 use function zend_version;
 use function zlib_encode;
+use const E_COMPILE_ERROR;
+use const E_CORE_ERROR;
+use const E_ERROR;
+use const E_PARSE;
+use const E_RECOVERABLE_ERROR;
+use const E_USER_ERROR;
 use const FILE_IGNORE_NEW_LINES;
 use const JSON_THROW_ON_ERROR;
 use const JSON_UNESCAPED_SLASHES;
@@ -85,6 +91,9 @@ class CrashDump{
 	public const PLUGIN_INVOLVEMENT_DIRECT = "direct";
 	public const PLUGIN_INVOLVEMENT_INDIRECT = "indirect";
 
+	public const FATAL_ERROR_MASK =
+		E_ERROR | E_PARSE | E_CORE_ERROR | E_COMPILE_ERROR | E_USER_ERROR | E_RECOVERABLE_ERROR;
+
 	private CrashDumpData $data;
 	private string $encodedData;
 
@@ -186,7 +195,7 @@ class CrashDump{
 			$error = $lastExceptionError;
 		}else{
 			$error = error_get_last();
-			if($error === null){
+			if($error === null || ($error["type"] & self::FATAL_ERROR_MASK) === 0){
 				throw new \RuntimeException("Crash error information missing - did something use exit()?");
 			}
 			$error["trace"] = Utils::printableTrace(Utils::currentTrace(3)); //Skipping CrashDump->baseCrash, CrashDump->construct, Server->crashDump

src/data/bedrock/BannerPatternTypeIdMap.php

@@ -43,44 +43,50 @@ final class BannerPatternTypeIdMap{
 	private array $enumToId = [];
 
 	public function __construct(){
-		$this->register("bo", BannerPatternType::BORDER);
-		$this->register("bri", BannerPatternType::BRICKS);
-		$this->register("mc", BannerPatternType::CIRCLE);
-		$this->register("cre", BannerPatternType::CREEPER);
-		$this->register("cr", BannerPatternType::CROSS);
-		$this->register("cbo", BannerPatternType::CURLY_BORDER);
-		$this->register("lud", BannerPatternType::DIAGONAL_LEFT);
-		$this->register("rd", BannerPatternType::DIAGONAL_RIGHT);
-		$this->register("ld", BannerPatternType::DIAGONAL_UP_LEFT);
-		$this->register("rud", BannerPatternType::DIAGONAL_UP_RIGHT);
-		$this->register("flo", BannerPatternType::FLOWER);
-		$this->register("gra", BannerPatternType::GRADIENT);
-		$this->register("gru", BannerPatternType::GRADIENT_UP);
-		$this->register("hh", BannerPatternType::HALF_HORIZONTAL);
-		$this->register("hhb", BannerPatternType::HALF_HORIZONTAL_BOTTOM);
-		$this->register("vh", BannerPatternType::HALF_VERTICAL);
-		$this->register("vhr", BannerPatternType::HALF_VERTICAL_RIGHT);
-		$this->register("moj", BannerPatternType::MOJANG);
-		$this->register("mr", BannerPatternType::RHOMBUS);
-		$this->register("sku", BannerPatternType::SKULL);
-		$this->register("ss", BannerPatternType::SMALL_STRIPES);
-		$this->register("bl", BannerPatternType::SQUARE_BOTTOM_LEFT);
-		$this->register("br", BannerPatternType::SQUARE_BOTTOM_RIGHT);
-		$this->register("tl", BannerPatternType::SQUARE_TOP_LEFT);
-		$this->register("tr", BannerPatternType::SQUARE_TOP_RIGHT);
-		$this->register("sc", BannerPatternType::STRAIGHT_CROSS);
-		$this->register("bs", BannerPatternType::STRIPE_BOTTOM);
-		$this->register("cs", BannerPatternType::STRIPE_CENTER);
-		$this->register("dls", BannerPatternType::STRIPE_DOWNLEFT);
-		$this->register("drs", BannerPatternType::STRIPE_DOWNRIGHT);
-		$this->register("ls", BannerPatternType::STRIPE_LEFT);
-		$this->register("ms", BannerPatternType::STRIPE_MIDDLE);
-		$this->register("rs", BannerPatternType::STRIPE_RIGHT);
-		$this->register("ts", BannerPatternType::STRIPE_TOP);
-		$this->register("bt", BannerPatternType::TRIANGLE_BOTTOM);
-		$this->register("tt", BannerPatternType::TRIANGLE_TOP);
-		$this->register("bts", BannerPatternType::TRIANGLES_BOTTOM);
-		$this->register("tts", BannerPatternType::TRIANGLES_TOP);
+		foreach(BannerPatternType::cases() as $case){
+			$this->register(match($case){
+				BannerPatternType::BORDER => "bo",
+				BannerPatternType::BRICKS => "bri",
+				BannerPatternType::CIRCLE => "mc",
+				BannerPatternType::CREEPER => "cre",
+				BannerPatternType::CROSS => "cr",
+				BannerPatternType::CURLY_BORDER => "cbo",
+				BannerPatternType::DIAGONAL_LEFT => "lud",
+				BannerPatternType::DIAGONAL_RIGHT => "rd",
+				BannerPatternType::DIAGONAL_UP_LEFT => "ld",
+				BannerPatternType::DIAGONAL_UP_RIGHT => "rud",
+				BannerPatternType::FLOWER => "flo",
+				BannerPatternType::GLOBE => "glb",
+				BannerPatternType::GRADIENT => "gra",
+				BannerPatternType::GRADIENT_UP => "gru",
+				BannerPatternType::HALF_HORIZONTAL => "hh",
+				BannerPatternType::HALF_HORIZONTAL_BOTTOM => "hhb",
+				BannerPatternType::HALF_VERTICAL => "vh",
+				BannerPatternType::HALF_VERTICAL_RIGHT => "vhr",
+				BannerPatternType::MOJANG => "moj",
+				BannerPatternType::PIGLIN => "pig",
+				BannerPatternType::RHOMBUS => "mr",
+				BannerPatternType::SKULL => "sku",
+				BannerPatternType::SMALL_STRIPES => "ss",
+				BannerPatternType::SQUARE_BOTTOM_LEFT => "bl",
+				BannerPatternType::SQUARE_BOTTOM_RIGHT => "br",
+				BannerPatternType::SQUARE_TOP_LEFT => "tl",
+				BannerPatternType::SQUARE_TOP_RIGHT => "tr",
+				BannerPatternType::STRAIGHT_CROSS => "sc",
+				BannerPatternType::STRIPE_BOTTOM => "bs",
+				BannerPatternType::STRIPE_CENTER => "cs",
+				BannerPatternType::STRIPE_DOWNLEFT => "dls",
+				BannerPatternType::STRIPE_DOWNRIGHT => "drs",
+				BannerPatternType::STRIPE_LEFT => "ls",
+				BannerPatternType::STRIPE_MIDDLE => "ms",
+				BannerPatternType::STRIPE_RIGHT => "rs",
+				BannerPatternType::STRIPE_TOP => "ts",
+				BannerPatternType::TRIANGLE_BOTTOM => "bt",
+				BannerPatternType::TRIANGLE_TOP => "tt",
+				BannerPatternType::TRIANGLES_BOTTOM => "bts",
+				BannerPatternType::TRIANGLES_TOP => "tts",
+			}, $case);
+		}
 	}
 
 	public function register(string $stringId, BannerPatternType $type) : void{

src/data/bedrock/BiomeIds.php

@@ -111,4 +111,15 @@ final class BiomeIds{
 	public const CRIMSON_FOREST = 179;
 	public const WARPED_FOREST = 180;
 	public const BASALT_DELTAS = 181;
+	public const JAGGED_PEAKS = 182;
+	public const FROZEN_PEAKS = 183;
+	public const SNOWY_SLOPES = 184;
+	public const GROVE = 185;
+	public const MEADOW = 186;
+	public const LUSH_CAVES = 187;
+	public const DRIPSTONE_CAVES = 188;
+	public const STONY_PEAKS = 189;
+	public const DEEP_DARK = 190;
+	public const MANGROVE_SWAMP = 191;
+	public const CHERRY_GROVE = 192;
 }

src/data/bedrock/DyeColorIdMap.php

@@ -48,22 +48,28 @@ final class DyeColorIdMap{
 	private array $enumToItemId = [];
 
 	private function __construct(){
-		$this->register(0, ItemTypeNames::WHITE_DYE, DyeColor::WHITE);
-		$this->register(1, ItemTypeNames::ORANGE_DYE, DyeColor::ORANGE);
-		$this->register(2, ItemTypeNames::MAGENTA_DYE, DyeColor::MAGENTA);
-		$this->register(3, ItemTypeNames::LIGHT_BLUE_DYE, DyeColor::LIGHT_BLUE);
-		$this->register(4, ItemTypeNames::YELLOW_DYE, DyeColor::YELLOW);
-		$this->register(5, ItemTypeNames::LIME_DYE, DyeColor::LIME);
-		$this->register(6, ItemTypeNames::PINK_DYE, DyeColor::PINK);
-		$this->register(7, ItemTypeNames::GRAY_DYE, DyeColor::GRAY);
-		$this->register(8, ItemTypeNames::LIGHT_GRAY_DYE, DyeColor::LIGHT_GRAY);
-		$this->register(9, ItemTypeNames::CYAN_DYE, DyeColor::CYAN);
-		$this->register(10, ItemTypeNames::PURPLE_DYE, DyeColor::PURPLE);
-		$this->register(11, ItemTypeNames::BLUE_DYE, DyeColor::BLUE);
-		$this->register(12, ItemTypeNames::BROWN_DYE, DyeColor::BROWN);
-		$this->register(13, ItemTypeNames::GREEN_DYE, DyeColor::GREEN);
-		$this->register(14, ItemTypeNames::RED_DYE, DyeColor::RED);
-		$this->register(15, ItemTypeNames::BLACK_DYE, DyeColor::BLACK);
+		foreach(DyeColor::cases() as $case){
+			[$colorId, $dyeItemId] = match($case){
+				DyeColor::WHITE => [0, ItemTypeNames::WHITE_DYE],
+				DyeColor::ORANGE => [1, ItemTypeNames::ORANGE_DYE],
+				DyeColor::MAGENTA => [2, ItemTypeNames::MAGENTA_DYE],
+				DyeColor::LIGHT_BLUE => [3, ItemTypeNames::LIGHT_BLUE_DYE],
+				DyeColor::YELLOW => [4, ItemTypeNames::YELLOW_DYE],
+				DyeColor::LIME => [5, ItemTypeNames::LIME_DYE],
+				DyeColor::PINK => [6, ItemTypeNames::PINK_DYE],
+				DyeColor::GRAY => [7, ItemTypeNames::GRAY_DYE],
+				DyeColor::LIGHT_GRAY => [8, ItemTypeNames::LIGHT_GRAY_DYE],
+				DyeColor::CYAN => [9, ItemTypeNames::CYAN_DYE],
+				DyeColor::PURPLE => [10, ItemTypeNames::PURPLE_DYE],
+				DyeColor::BLUE => [11, ItemTypeNames::BLUE_DYE],
+				DyeColor::BROWN => [12, ItemTypeNames::BROWN_DYE],
+				DyeColor::GREEN => [13, ItemTypeNames::GREEN_DYE],
+				DyeColor::RED => [14, ItemTypeNames::RED_DYE],
+				DyeColor::BLACK => [15, ItemTypeNames::BLACK_DYE],
+			};
+
+			$this->register($colorId, $dyeItemId, $case);
+		}
 	}
 
 	private function register(int $id, string $itemId, DyeColor $color) : void{

src/data/bedrock/MedicineTypeIdMap.php

@@ -32,9 +32,13 @@ final class MedicineTypeIdMap{
 	use IntSaveIdMapTrait;
 
 	private function __construct(){
-		$this->register(MedicineTypeIds::ANTIDOTE, MedicineType::ANTIDOTE);
-		$this->register(MedicineTypeIds::ELIXIR, MedicineType::ELIXIR);
-		$this->register(MedicineTypeIds::EYE_DROPS, MedicineType::EYE_DROPS);
-		$this->register(MedicineTypeIds::TONIC, MedicineType::TONIC);
+		foreach(MedicineType::cases() as $case){
+			$this->register(match($case){
+				MedicineType::ANTIDOTE => MedicineTypeIds::ANTIDOTE,
+				MedicineType::ELIXIR => MedicineTypeIds::ELIXIR,
+				MedicineType::EYE_DROPS => MedicineTypeIds::EYE_DROPS,
+				MedicineType::TONIC => MedicineTypeIds::TONIC,
+			}, $case);
+		}
 	}
 }

src/data/bedrock/MobHeadTypeIdMap.php

@@ -32,12 +32,16 @@ final class MobHeadTypeIdMap{
 	use IntSaveIdMapTrait;
 
 	private function __construct(){
-		$this->register(0, MobHeadType::SKELETON);
-		$this->register(1, MobHeadType::WITHER_SKELETON);
-		$this->register(2, MobHeadType::ZOMBIE);
-		$this->register(3, MobHeadType::PLAYER);
-		$this->register(4, MobHeadType::CREEPER);
-		$this->register(5, MobHeadType::DRAGON);
-		$this->register(6, MobHeadType::PIGLIN);
+		foreach(MobHeadType::cases() as $case){
+			$this->register(match($case){
+				MobHeadType::SKELETON => 0,
+				MobHeadType::WITHER_SKELETON => 1,
+				MobHeadType::ZOMBIE => 2,
+				MobHeadType::PLAYER => 3,
+				MobHeadType::CREEPER => 4,
+				MobHeadType::DRAGON => 5,
+				MobHeadType::PIGLIN => 6,
+			}, $case);
+		}
 	}
 }

src/data/bedrock/MushroomBlockTypeIdMap.php

@@ -33,16 +33,20 @@ final class MushroomBlockTypeIdMap{
 	use IntSaveIdMapTrait;
 
 	public function __construct(){
-		$this->register(LegacyMeta::MUSHROOM_BLOCK_ALL_PORES, MushroomBlockType::PORES);
-		$this->register(LegacyMeta::MUSHROOM_BLOCK_CAP_NORTHWEST_CORNER, MushroomBlockType::CAP_NORTHWEST);
-		$this->register(LegacyMeta::MUSHROOM_BLOCK_CAP_NORTH_SIDE, MushroomBlockType::CAP_NORTH);
-		$this->register(LegacyMeta::MUSHROOM_BLOCK_CAP_NORTHEAST_CORNER, MushroomBlockType::CAP_NORTHEAST);
-		$this->register(LegacyMeta::MUSHROOM_BLOCK_CAP_WEST_SIDE, MushroomBlockType::CAP_WEST);
-		$this->register(LegacyMeta::MUSHROOM_BLOCK_CAP_TOP_ONLY, MushroomBlockType::CAP_MIDDLE);
-		$this->register(LegacyMeta::MUSHROOM_BLOCK_CAP_EAST_SIDE, MushroomBlockType::CAP_EAST);
-		$this->register(LegacyMeta::MUSHROOM_BLOCK_CAP_SOUTHWEST_CORNER, MushroomBlockType::CAP_SOUTHWEST);
-		$this->register(LegacyMeta::MUSHROOM_BLOCK_CAP_SOUTH_SIDE, MushroomBlockType::CAP_SOUTH);
-		$this->register(LegacyMeta::MUSHROOM_BLOCK_CAP_SOUTHEAST_CORNER, MushroomBlockType::CAP_SOUTHEAST);
-		$this->register(LegacyMeta::MUSHROOM_BLOCK_ALL_CAP, MushroomBlockType::ALL_CAP);
+		foreach(MushroomBlockType::cases() as $case){
+			$this->register(match($case){
+				MushroomBlockType::PORES => LegacyMeta::MUSHROOM_BLOCK_ALL_PORES,
+				MushroomBlockType::CAP_NORTHWEST => LegacyMeta::MUSHROOM_BLOCK_CAP_NORTHWEST_CORNER,
+				MushroomBlockType::CAP_NORTH => LegacyMeta::MUSHROOM_BLOCK_CAP_NORTH_SIDE,
+				MushroomBlockType::CAP_NORTHEAST => LegacyMeta::MUSHROOM_BLOCK_CAP_NORTHEAST_CORNER,
+				MushroomBlockType::CAP_WEST => LegacyMeta::MUSHROOM_BLOCK_CAP_WEST_SIDE,
+				MushroomBlockType::CAP_MIDDLE => LegacyMeta::MUSHROOM_BLOCK_CAP_TOP_ONLY,
+				MushroomBlockType::CAP_EAST => LegacyMeta::MUSHROOM_BLOCK_CAP_EAST_SIDE,
+				MushroomBlockType::CAP_SOUTHWEST => LegacyMeta::MUSHROOM_BLOCK_CAP_SOUTHWEST_CORNER,
+				MushroomBlockType::CAP_SOUTH => LegacyMeta::MUSHROOM_BLOCK_CAP_SOUTH_SIDE,
+				MushroomBlockType::CAP_SOUTHEAST => LegacyMeta::MUSHROOM_BLOCK_CAP_SOUTHEAST_CORNER,
+				MushroomBlockType::ALL_CAP => LegacyMeta::MUSHROOM_BLOCK_ALL_CAP,
+			}, $case);
+		}
 	}
 }

src/data/bedrock/NoteInstrumentIdMap.php

@@ -32,21 +32,25 @@ final class NoteInstrumentIdMap{
 	use IntSaveIdMapTrait;
 
 	private function __construct(){
-		$this->register(0, NoteInstrument::PIANO);
-		$this->register(1, NoteInstrument::BASS_DRUM);
-		$this->register(2, NoteInstrument::SNARE);
-		$this->register(3, NoteInstrument::CLICKS_AND_STICKS);
-		$this->register(4, NoteInstrument::DOUBLE_BASS);
-		$this->register(5, NoteInstrument::BELL);
-		$this->register(6, NoteInstrument::FLUTE);
-		$this->register(7, NoteInstrument::CHIME);
-		$this->register(8, NoteInstrument::GUITAR);
-		$this->register(9, NoteInstrument::XYLOPHONE);
-		$this->register(10, NoteInstrument::IRON_XYLOPHONE);
-		$this->register(11, NoteInstrument::COW_BELL);
-		$this->register(12, NoteInstrument::DIDGERIDOO);
-		$this->register(13, NoteInstrument::BIT);
-		$this->register(14, NoteInstrument::BANJO);
-		$this->register(15, NoteInstrument::PLING);
+		foreach(NoteInstrument::cases() as $case){
+			$this->register(match($case){
+				NoteInstrument::PIANO => 0,
+				NoteInstrument::BASS_DRUM => 1,
+				NoteInstrument::SNARE => 2,
+				NoteInstrument::CLICKS_AND_STICKS => 3,
+				NoteInstrument::DOUBLE_BASS => 4,
+				NoteInstrument::BELL => 5,
+				NoteInstrument::FLUTE => 6,
+				NoteInstrument::CHIME => 7,
+				NoteInstrument::GUITAR => 8,
+				NoteInstrument::XYLOPHONE => 9,
+				NoteInstrument::IRON_XYLOPHONE => 10,
+				NoteInstrument::COW_BELL => 11,
+				NoteInstrument::DIDGERIDOO => 12,
+				NoteInstrument::BIT => 13,
+				NoteInstrument::BANJO => 14,
+				NoteInstrument::PLING => 15,
+			}, $case);
+		}
 	}
 }

src/data/bedrock/PotionTypeIdMap.php

@@ -32,48 +32,52 @@ final class PotionTypeIdMap{
 	use IntSaveIdMapTrait;
 
 	private function __construct(){
-		$this->register(PotionTypeIds::WATER, PotionType::WATER);
-		$this->register(PotionTypeIds::MUNDANE, PotionType::MUNDANE);
-		$this->register(PotionTypeIds::LONG_MUNDANE, PotionType::LONG_MUNDANE);
-		$this->register(PotionTypeIds::THICK, PotionType::THICK);
-		$this->register(PotionTypeIds::AWKWARD, PotionType::AWKWARD);
-		$this->register(PotionTypeIds::NIGHT_VISION, PotionType::NIGHT_VISION);
-		$this->register(PotionTypeIds::LONG_NIGHT_VISION, PotionType::LONG_NIGHT_VISION);
-		$this->register(PotionTypeIds::INVISIBILITY, PotionType::INVISIBILITY);
-		$this->register(PotionTypeIds::LONG_INVISIBILITY, PotionType::LONG_INVISIBILITY);
-		$this->register(PotionTypeIds::LEAPING, PotionType::LEAPING);
-		$this->register(PotionTypeIds::LONG_LEAPING, PotionType::LONG_LEAPING);
-		$this->register(PotionTypeIds::STRONG_LEAPING, PotionType::STRONG_LEAPING);
-		$this->register(PotionTypeIds::FIRE_RESISTANCE, PotionType::FIRE_RESISTANCE);
-		$this->register(PotionTypeIds::LONG_FIRE_RESISTANCE, PotionType::LONG_FIRE_RESISTANCE);
-		$this->register(PotionTypeIds::SWIFTNESS, PotionType::SWIFTNESS);
-		$this->register(PotionTypeIds::LONG_SWIFTNESS, PotionType::LONG_SWIFTNESS);
-		$this->register(PotionTypeIds::STRONG_SWIFTNESS, PotionType::STRONG_SWIFTNESS);
-		$this->register(PotionTypeIds::SLOWNESS, PotionType::SLOWNESS);
-		$this->register(PotionTypeIds::LONG_SLOWNESS, PotionType::LONG_SLOWNESS);
-		$this->register(PotionTypeIds::WATER_BREATHING, PotionType::WATER_BREATHING);
-		$this->register(PotionTypeIds::LONG_WATER_BREATHING, PotionType::LONG_WATER_BREATHING);
-		$this->register(PotionTypeIds::HEALING, PotionType::HEALING);
-		$this->register(PotionTypeIds::STRONG_HEALING, PotionType::STRONG_HEALING);
-		$this->register(PotionTypeIds::HARMING, PotionType::HARMING);
-		$this->register(PotionTypeIds::STRONG_HARMING, PotionType::STRONG_HARMING);
-		$this->register(PotionTypeIds::POISON, PotionType::POISON);
-		$this->register(PotionTypeIds::LONG_POISON, PotionType::LONG_POISON);
-		$this->register(PotionTypeIds::STRONG_POISON, PotionType::STRONG_POISON);
-		$this->register(PotionTypeIds::REGENERATION, PotionType::REGENERATION);
-		$this->register(PotionTypeIds::LONG_REGENERATION, PotionType::LONG_REGENERATION);
-		$this->register(PotionTypeIds::STRONG_REGENERATION, PotionType::STRONG_REGENERATION);
-		$this->register(PotionTypeIds::STRENGTH, PotionType::STRENGTH);
-		$this->register(PotionTypeIds::LONG_STRENGTH, PotionType::LONG_STRENGTH);
-		$this->register(PotionTypeIds::STRONG_STRENGTH, PotionType::STRONG_STRENGTH);
-		$this->register(PotionTypeIds::WEAKNESS, PotionType::WEAKNESS);
-		$this->register(PotionTypeIds::LONG_WEAKNESS, PotionType::LONG_WEAKNESS);
-		$this->register(PotionTypeIds::WITHER, PotionType::WITHER);
-		$this->register(PotionTypeIds::TURTLE_MASTER, PotionType::TURTLE_MASTER);
-		$this->register(PotionTypeIds::LONG_TURTLE_MASTER, PotionType::LONG_TURTLE_MASTER);
-		$this->register(PotionTypeIds::STRONG_TURTLE_MASTER, PotionType::STRONG_TURTLE_MASTER);
-		$this->register(PotionTypeIds::SLOW_FALLING, PotionType::SLOW_FALLING);
-		$this->register(PotionTypeIds::LONG_SLOW_FALLING, PotionType::LONG_SLOW_FALLING);
-		$this->register(PotionTypeIds::STRONG_SLOWNESS, PotionType::STRONG_SLOWNESS);
+		foreach(PotionType::cases() as $case){
+			$this->register(match($case){
+				PotionType::WATER => PotionTypeIds::WATER,
+				PotionType::MUNDANE => PotionTypeIds::MUNDANE,
+				PotionType::LONG_MUNDANE => PotionTypeIds::LONG_MUNDANE,
+				PotionType::THICK => PotionTypeIds::THICK,
+				PotionType::AWKWARD => PotionTypeIds::AWKWARD,
+				PotionType::NIGHT_VISION => PotionTypeIds::NIGHT_VISION,
+				PotionType::LONG_NIGHT_VISION => PotionTypeIds::LONG_NIGHT_VISION,
+				PotionType::INVISIBILITY => PotionTypeIds::INVISIBILITY,
+				PotionType::LONG_INVISIBILITY => PotionTypeIds::LONG_INVISIBILITY,
+				PotionType::LEAPING => PotionTypeIds::LEAPING,
+				PotionType::LONG_LEAPING => PotionTypeIds::LONG_LEAPING,
+				PotionType::STRONG_LEAPING => PotionTypeIds::STRONG_LEAPING,
+				PotionType::FIRE_RESISTANCE => PotionTypeIds::FIRE_RESISTANCE,
+				PotionType::LONG_FIRE_RESISTANCE => PotionTypeIds::LONG_FIRE_RESISTANCE,
+				PotionType::SWIFTNESS => PotionTypeIds::SWIFTNESS,
+				PotionType::LONG_SWIFTNESS => PotionTypeIds::LONG_SWIFTNESS,
+				PotionType::STRONG_SWIFTNESS => PotionTypeIds::STRONG_SWIFTNESS,
+				PotionType::SLOWNESS => PotionTypeIds::SLOWNESS,
+				PotionType::LONG_SLOWNESS => PotionTypeIds::LONG_SLOWNESS,
+				PotionType::WATER_BREATHING => PotionTypeIds::WATER_BREATHING,
+				PotionType::LONG_WATER_BREATHING => PotionTypeIds::LONG_WATER_BREATHING,
+				PotionType::HEALING => PotionTypeIds::HEALING,
+				PotionType::STRONG_HEALING => PotionTypeIds::STRONG_HEALING,
+				PotionType::HARMING => PotionTypeIds::HARMING,
+				PotionType::STRONG_HARMING => PotionTypeIds::STRONG_HARMING,
+				PotionType::POISON => PotionTypeIds::POISON,
+				PotionType::LONG_POISON => PotionTypeIds::LONG_POISON,
+				PotionType::STRONG_POISON => PotionTypeIds::STRONG_POISON,
+				PotionType::REGENERATION => PotionTypeIds::REGENERATION,
+				PotionType::LONG_REGENERATION => PotionTypeIds::LONG_REGENERATION,
+				PotionType::STRONG_REGENERATION => PotionTypeIds::STRONG_REGENERATION,
+				PotionType::STRENGTH => PotionTypeIds::STRENGTH,
+				PotionType::LONG_STRENGTH => PotionTypeIds::LONG_STRENGTH,
+				PotionType::STRONG_STRENGTH => PotionTypeIds::STRONG_STRENGTH,
+				PotionType::WEAKNESS => PotionTypeIds::WEAKNESS,
+				PotionType::LONG_WEAKNESS => PotionTypeIds::LONG_WEAKNESS,
+				PotionType::WITHER => PotionTypeIds::WITHER,
+				PotionType::TURTLE_MASTER => PotionTypeIds::TURTLE_MASTER,
+				PotionType::LONG_TURTLE_MASTER => PotionTypeIds::LONG_TURTLE_MASTER,
+				PotionType::STRONG_TURTLE_MASTER => PotionTypeIds::STRONG_TURTLE_MASTER,
+				PotionType::SLOW_FALLING => PotionTypeIds::SLOW_FALLING,
+				PotionType::LONG_SLOW_FALLING => PotionTypeIds::LONG_SLOW_FALLING,
+				PotionType::STRONG_SLOWNESS => PotionTypeIds::STRONG_SLOWNESS,
+			}, $case);
+		}
 	}
 }

src/data/bedrock/SuspiciousStewTypeIdMap.php

@@ -32,15 +32,20 @@ final class SuspiciousStewTypeIdMap{
 	use IntSaveIdMapTrait;
 
 	private function __construct(){
-		$this->register(SuspiciousStewTypeIds::POPPY, SuspiciousStewType::POPPY);
-		$this->register(SuspiciousStewTypeIds::CORNFLOWER, SuspiciousStewType::CORNFLOWER);
-		$this->register(SuspiciousStewTypeIds::TULIP, SuspiciousStewType::TULIP);
-		$this->register(SuspiciousStewTypeIds::AZURE_BLUET, SuspiciousStewType::AZURE_BLUET);
-		$this->register(SuspiciousStewTypeIds::LILY_OF_THE_VALLEY, SuspiciousStewType::LILY_OF_THE_VALLEY);
-		$this->register(SuspiciousStewTypeIds::DANDELION, SuspiciousStewType::DANDELION);
-		$this->register(SuspiciousStewTypeIds::BLUE_ORCHID, SuspiciousStewType::BLUE_ORCHID);
-		$this->register(SuspiciousStewTypeIds::ALLIUM, SuspiciousStewType::ALLIUM);
-		$this->register(SuspiciousStewTypeIds::OXEYE_DAISY, SuspiciousStewType::OXEYE_DAISY);
-		$this->register(SuspiciousStewTypeIds::WITHER_ROSE, SuspiciousStewType::WITHER_ROSE);
+		foreach(SuspiciousStewType::cases() as $case){
+			$this->register(match($case){
+				SuspiciousStewType::POPPY => SuspiciousStewTypeIds::POPPY,
+				SuspiciousStewType::CORNFLOWER => SuspiciousStewTypeIds::CORNFLOWER,
+				SuspiciousStewType::TULIP => SuspiciousStewTypeIds::TULIP,
+				SuspiciousStewType::AZURE_BLUET => SuspiciousStewTypeIds::AZURE_BLUET,
+				SuspiciousStewType::LILY_OF_THE_VALLEY => SuspiciousStewTypeIds::LILY_OF_THE_VALLEY,
+				SuspiciousStewType::DANDELION => SuspiciousStewTypeIds::DANDELION,
+				SuspiciousStewType::BLUE_ORCHID => SuspiciousStewTypeIds::BLUE_ORCHID,
+				SuspiciousStewType::ALLIUM => SuspiciousStewTypeIds::ALLIUM,
+				SuspiciousStewType::OXEYE_DAISY => SuspiciousStewTypeIds::OXEYE_DAISY,
+				SuspiciousStewType::WITHER_ROSE => SuspiciousStewTypeIds::WITHER_ROSE,
+			}, $case);
+		}
+
 	}
 }

src/data/bedrock/block/BlockStateData.php

@@ -38,12 +38,15 @@ use function implode;
 final class BlockStateData{
 	/**
 	 * Bedrock version of the most recent backwards-incompatible change to blockstates.
+	 *
+	 * This is *not* the same as current game version. It should match the numbers in the
+	 * newest blockstate upgrade schema used in BedrockBlockUpgradeSchema.
 	 */
 	public const CURRENT_VERSION =
 		(1 << 24) | //major
-		(20 << 16) | //minor
-		(40 << 8) | //patch
-		(3); //revision
+		(21 << 16) | //minor
+		(20 << 8) | //patch
+		(6); //revision
 
 	public const TAG_NAME = "name";
 	public const TAG_STATES = "states";

src/data/bedrock/block/BlockStateNames.php

@@ -42,7 +42,6 @@ final class BlockStateNames{
 	public const BIG_DRIPLEAF_HEAD = "big_dripleaf_head";
 	public const BIG_DRIPLEAF_TILT = "big_dripleaf_tilt";
 	public const BITE_COUNTER = "bite_counter";
-	public const BLOCK_LIGHT_LEVEL = "block_light_level";
 	public const BLOOM = "bloom";
 	public const BOOKS_STORED = "books_stored";
 	public const BREWING_STAND_SLOT_A_BIT = "brewing_stand_slot_a_bit";
@@ -56,24 +55,19 @@ final class BlockStateNames{
 	public const CHEMISTRY_TABLE_TYPE = "chemistry_table_type";
 	public const CHISEL_TYPE = "chisel_type";
 	public const CLUSTER_COUNT = "cluster_count";
-	public const COLOR = "color";
 	public const COLOR_BIT = "color_bit";
 	public const COMPOSTER_FILL_LEVEL = "composter_fill_level";
 	public const CONDITIONAL_BIT = "conditional_bit";
-	public const CORAL_COLOR = "coral_color";
 	public const CORAL_DIRECTION = "coral_direction";
 	public const CORAL_FAN_DIRECTION = "coral_fan_direction";
-	public const CORAL_HANG_TYPE_BIT = "coral_hang_type_bit";
 	public const COVERED_BIT = "covered_bit";
 	public const CRACKED_STATE = "cracked_state";
-	public const DAMAGE = "damage";
+	public const CRAFTING = "crafting";
 	public const DEAD_BIT = "dead_bit";
 	public const DEPRECATED = "deprecated";
 	public const DIRECTION = "direction";
-	public const DIRT_TYPE = "dirt_type";
 	public const DISARMED_BIT = "disarmed_bit";
 	public const DOOR_HINGE_BIT = "door_hinge_bit";
-	public const DOUBLE_PLANT_TYPE = "double_plant_type";
 	public const DRAG_DOWN = "drag_down";
 	public const DRIPSTONE_THICKNESS = "dripstone_thickness";
 	public const END_PORTAL_EYE_BIT = "end_portal_eye_bit";
@@ -81,7 +75,6 @@ final class BlockStateNames{
 	public const EXTINGUISHED = "extinguished";
 	public const FACING_DIRECTION = "facing_direction";
 	public const FILL_LEVEL = "fill_level";
-	public const FLOWER_TYPE = "flower_type";
 	public const GROUND_SIGN_DIRECTION = "ground_sign_direction";
 	public const GROWING_PLANT_AGE = "growing_plant_age";
 	public const GROWTH = "growth";
@@ -103,19 +96,17 @@ final class BlockStateNames{
 	public const MC_FACING_DIRECTION = "minecraft:facing_direction";
 	public const MC_VERTICAL_HALF = "minecraft:vertical_half";
 	public const MOISTURIZED_AMOUNT = "moisturized_amount";
-	public const MONSTER_EGG_STONE_TYPE = "monster_egg_stone_type";
 	public const MULTI_FACE_DIRECTION_BITS = "multi_face_direction_bits";
-	public const NEW_LEAF_TYPE = "new_leaf_type";
 	public const OCCUPIED_BIT = "occupied_bit";
-	public const OLD_LEAF_TYPE = "old_leaf_type";
+	public const OMINOUS = "ominous";
 	public const OPEN_BIT = "open_bit";
+	public const ORIENTATION = "orientation";
 	public const OUTPUT_LIT_BIT = "output_lit_bit";
 	public const OUTPUT_SUBTRACT_BIT = "output_subtract_bit";
 	public const PERSISTENT_BIT = "persistent_bit";
 	public const PILLAR_AXIS = "pillar_axis";
 	public const PORTAL_AXIS = "portal_axis";
 	public const POWERED_BIT = "powered_bit";
-	public const PRISMARINE_BLOCK_TYPE = "prismarine_block_type";
 	public const PROPAGULE_STAGE = "propagule_stage";
 	public const RAIL_DATA_BIT = "rail_data_bit";
 	public const RAIL_DIRECTION = "rail_direction";
@@ -123,33 +114,25 @@ final class BlockStateNames{
 	public const REPEATER_DELAY = "repeater_delay";
 	public const RESPAWN_ANCHOR_CHARGE = "respawn_anchor_charge";
 	public const ROTATION = "rotation";
-	public const SAND_STONE_TYPE = "sand_stone_type";
-	public const SAND_TYPE = "sand_type";
-	public const SAPLING_TYPE = "sapling_type";
 	public const SCULK_SENSOR_PHASE = "sculk_sensor_phase";
 	public const SEA_GRASS_TYPE = "sea_grass_type";
 	public const SPONGE_TYPE = "sponge_type";
 	public const STABILITY = "stability";
 	public const STABILITY_CHECK = "stability_check";
-	public const STONE_BRICK_TYPE = "stone_brick_type";
-	public const STONE_SLAB_TYPE = "stone_slab_type";
-	public const STONE_SLAB_TYPE_2 = "stone_slab_type_2";
-	public const STONE_SLAB_TYPE_3 = "stone_slab_type_3";
-	public const STONE_SLAB_TYPE_4 = "stone_slab_type_4";
-	public const STONE_TYPE = "stone_type";
 	public const STRIPPED_BIT = "stripped_bit";
 	public const STRUCTURE_BLOCK_TYPE = "structure_block_type";
 	public const STRUCTURE_VOID_TYPE = "structure_void_type";
 	public const SUSPENDED_BIT = "suspended_bit";
-	public const TALL_GRASS_TYPE = "tall_grass_type";
 	public const TOGGLE_BIT = "toggle_bit";
 	public const TORCH_FACING_DIRECTION = "torch_facing_direction";
+	public const TRIAL_SPAWNER_STATE = "trial_spawner_state";
 	public const TRIGGERED_BIT = "triggered_bit";
 	public const TURTLE_EGG_COUNT = "turtle_egg_count";
 	public const TWISTING_VINES_AGE = "twisting_vines_age";
 	public const UPDATE_BIT = "update_bit";
 	public const UPPER_BLOCK_BIT = "upper_block_bit";
 	public const UPSIDE_DOWN_BIT = "upside_down_bit";
+	public const VAULT_STATE = "vault_state";
 	public const VINE_DIRECTION_BITS = "vine_direction_bits";
 	public const WALL_BLOCK_TYPE = "wall_block_type";
 	public const WALL_CONNECTION_TYPE_EAST = "wall_connection_type_east";
@@ -159,5 +142,4 @@ final class BlockStateNames{
 	public const WALL_POST_BIT = "wall_post_bit";
 	public const WEEPING_VINES_AGE = "weeping_vines_age";
 	public const WEIRDO_DIRECTION = "weirdo_direction";
-	public const WOOD_TYPE = "wood_type";
 }

src/data/bedrock/block/BlockStateStringValues.php

@@ -62,66 +62,16 @@ final class BlockStateStringValues{
 	public const CHISEL_TYPE_LINES = "lines";
 	public const CHISEL_TYPE_SMOOTH = "smooth";
 
-	public const COLOR_BLACK = "black";
-	public const COLOR_BLUE = "blue";
-	public const COLOR_BROWN = "brown";
-	public const COLOR_CYAN = "cyan";
-	public const COLOR_GRAY = "gray";
-	public const COLOR_GREEN = "green";
-	public const COLOR_LIGHT_BLUE = "light_blue";
-	public const COLOR_LIME = "lime";
-	public const COLOR_MAGENTA = "magenta";
-	public const COLOR_ORANGE = "orange";
-	public const COLOR_PINK = "pink";
-	public const COLOR_PURPLE = "purple";
-	public const COLOR_RED = "red";
-	public const COLOR_SILVER = "silver";
-	public const COLOR_WHITE = "white";
-	public const COLOR_YELLOW = "yellow";
-
-	public const CORAL_COLOR_BLUE = "blue";
-	public const CORAL_COLOR_PINK = "pink";
-	public const CORAL_COLOR_PURPLE = "purple";
-	public const CORAL_COLOR_RED = "red";
-	public const CORAL_COLOR_YELLOW = "yellow";
-
 	public const CRACKED_STATE_CRACKED = "cracked";
 	public const CRACKED_STATE_MAX_CRACKED = "max_cracked";
 	public const CRACKED_STATE_NO_CRACKS = "no_cracks";
 
-	public const DAMAGE_BROKEN = "broken";
-	public const DAMAGE_SLIGHTLY_DAMAGED = "slightly_damaged";
-	public const DAMAGE_UNDAMAGED = "undamaged";
-	public const DAMAGE_VERY_DAMAGED = "very_damaged";
-
-	public const DIRT_TYPE_COARSE = "coarse";
-	public const DIRT_TYPE_NORMAL = "normal";
-
-	public const DOUBLE_PLANT_TYPE_FERN = "fern";
-	public const DOUBLE_PLANT_TYPE_GRASS = "grass";
-	public const DOUBLE_PLANT_TYPE_PAEONIA = "paeonia";
-	public const DOUBLE_PLANT_TYPE_ROSE = "rose";
-	public const DOUBLE_PLANT_TYPE_SUNFLOWER = "sunflower";
-	public const DOUBLE_PLANT_TYPE_SYRINGA = "syringa";
-
 	public const DRIPSTONE_THICKNESS_BASE = "base";
 	public const DRIPSTONE_THICKNESS_FRUSTUM = "frustum";
 	public const DRIPSTONE_THICKNESS_MERGE = "merge";
 	public const DRIPSTONE_THICKNESS_MIDDLE = "middle";
 	public const DRIPSTONE_THICKNESS_TIP = "tip";
 
-	public const FLOWER_TYPE_ALLIUM = "allium";
-	public const FLOWER_TYPE_CORNFLOWER = "cornflower";
-	public const FLOWER_TYPE_HOUSTONIA = "houstonia";
-	public const FLOWER_TYPE_LILY_OF_THE_VALLEY = "lily_of_the_valley";
-	public const FLOWER_TYPE_ORCHID = "orchid";
-	public const FLOWER_TYPE_OXEYE = "oxeye";
-	public const FLOWER_TYPE_POPPY = "poppy";
-	public const FLOWER_TYPE_TULIP_ORANGE = "tulip_orange";
-	public const FLOWER_TYPE_TULIP_PINK = "tulip_pink";
-	public const FLOWER_TYPE_TULIP_RED = "tulip_red";
-	public const FLOWER_TYPE_TULIP_WHITE = "tulip_white";
-
 	public const LEVER_DIRECTION_DOWN_EAST_WEST = "down_east_west";
 	public const LEVER_DIRECTION_DOWN_NORTH_SOUTH = "down_north_south";
 	public const LEVER_DIRECTION_EAST = "east";
@@ -153,20 +103,18 @@ final class BlockStateStringValues{
 	public const MC_VERTICAL_HALF_BOTTOM = "bottom";
 	public const MC_VERTICAL_HALF_TOP = "top";
 
-	public const MONSTER_EGG_STONE_TYPE_CHISELED_STONE_BRICK = "chiseled_stone_brick";
-	public const MONSTER_EGG_STONE_TYPE_COBBLESTONE = "cobblestone";
-	public const MONSTER_EGG_STONE_TYPE_CRACKED_STONE_BRICK = "cracked_stone_brick";
-	public const MONSTER_EGG_STONE_TYPE_MOSSY_STONE_BRICK = "mossy_stone_brick";
-	public const MONSTER_EGG_STONE_TYPE_STONE = "stone";
-	public const MONSTER_EGG_STONE_TYPE_STONE_BRICK = "stone_brick";
-
-	public const NEW_LEAF_TYPE_ACACIA = "acacia";
-	public const NEW_LEAF_TYPE_DARK_OAK = "dark_oak";
-
-	public const OLD_LEAF_TYPE_BIRCH = "birch";
-	public const OLD_LEAF_TYPE_JUNGLE = "jungle";
-	public const OLD_LEAF_TYPE_OAK = "oak";
-	public const OLD_LEAF_TYPE_SPRUCE = "spruce";
+	public const ORIENTATION_DOWN_EAST = "down_east";
+	public const ORIENTATION_DOWN_NORTH = "down_north";
+	public const ORIENTATION_DOWN_SOUTH = "down_south";
+	public const ORIENTATION_DOWN_WEST = "down_west";
+	public const ORIENTATION_EAST_UP = "east_up";
+	public const ORIENTATION_NORTH_UP = "north_up";
+	public const ORIENTATION_SOUTH_UP = "south_up";
+	public const ORIENTATION_UP_EAST = "up_east";
+	public const ORIENTATION_UP_NORTH = "up_north";
+	public const ORIENTATION_UP_SOUTH = "up_south";
+	public const ORIENTATION_UP_WEST = "up_west";
+	public const ORIENTATION_WEST_UP = "west_up";
 
 	public const PILLAR_AXIS_X = "x";
 	public const PILLAR_AXIS_Y = "y";
@@ -176,25 +124,6 @@ final class BlockStateStringValues{
 	public const PORTAL_AXIS_X = "x";
 	public const PORTAL_AXIS_Z = "z";
 
-	public const PRISMARINE_BLOCK_TYPE_BRICKS = "bricks";
-	public const PRISMARINE_BLOCK_TYPE_DARK = "dark";
-	public const PRISMARINE_BLOCK_TYPE_DEFAULT = "default";
-
-	public const SAND_STONE_TYPE_CUT = "cut";
-	public const SAND_STONE_TYPE_DEFAULT = "default";
-	public const SAND_STONE_TYPE_HEIROGLYPHS = "heiroglyphs";
-	public const SAND_STONE_TYPE_SMOOTH = "smooth";
-
-	public const SAND_TYPE_NORMAL = "normal";
-	public const SAND_TYPE_RED = "red";
-
-	public const SAPLING_TYPE_ACACIA = "acacia";
-	public const SAPLING_TYPE_BIRCH = "birch";
-	public const SAPLING_TYPE_DARK_OAK = "dark_oak";
-	public const SAPLING_TYPE_JUNGLE = "jungle";
-	public const SAPLING_TYPE_OAK = "oak";
-	public const SAPLING_TYPE_SPRUCE = "spruce";
-
 	public const SEA_GRASS_TYPE_DEFAULT = "default";
 	public const SEA_GRASS_TYPE_DOUBLE_BOT = "double_bot";
 	public const SEA_GRASS_TYPE_DOUBLE_TOP = "double_top";
@@ -202,53 +131,6 @@ final class BlockStateStringValues{
 	public const SPONGE_TYPE_DRY = "dry";
 	public const SPONGE_TYPE_WET = "wet";
 
-	public const STONE_BRICK_TYPE_CHISELED = "chiseled";
-	public const STONE_BRICK_TYPE_CRACKED = "cracked";
-	public const STONE_BRICK_TYPE_DEFAULT = "default";
-	public const STONE_BRICK_TYPE_MOSSY = "mossy";
-	public const STONE_BRICK_TYPE_SMOOTH = "smooth";
-
-	public const STONE_SLAB_TYPE_BRICK = "brick";
-	public const STONE_SLAB_TYPE_COBBLESTONE = "cobblestone";
-	public const STONE_SLAB_TYPE_NETHER_BRICK = "nether_brick";
-	public const STONE_SLAB_TYPE_QUARTZ = "quartz";
-	public const STONE_SLAB_TYPE_SANDSTONE = "sandstone";
-	public const STONE_SLAB_TYPE_SMOOTH_STONE = "smooth_stone";
-	public const STONE_SLAB_TYPE_STONE_BRICK = "stone_brick";
-	public const STONE_SLAB_TYPE_WOOD = "wood";
-
-	public const STONE_SLAB_TYPE_2_MOSSY_COBBLESTONE = "mossy_cobblestone";
-	public const STONE_SLAB_TYPE_2_PRISMARINE_BRICK = "prismarine_brick";
-	public const STONE_SLAB_TYPE_2_PRISMARINE_DARK = "prismarine_dark";
-	public const STONE_SLAB_TYPE_2_PRISMARINE_ROUGH = "prismarine_rough";
-	public const STONE_SLAB_TYPE_2_PURPUR = "purpur";
-	public const STONE_SLAB_TYPE_2_RED_NETHER_BRICK = "red_nether_brick";
-	public const STONE_SLAB_TYPE_2_RED_SANDSTONE = "red_sandstone";
-	public const STONE_SLAB_TYPE_2_SMOOTH_SANDSTONE = "smooth_sandstone";
-
-	public const STONE_SLAB_TYPE_3_ANDESITE = "andesite";
-	public const STONE_SLAB_TYPE_3_DIORITE = "diorite";
-	public const STONE_SLAB_TYPE_3_END_STONE_BRICK = "end_stone_brick";
-	public const STONE_SLAB_TYPE_3_GRANITE = "granite";
-	public const STONE_SLAB_TYPE_3_POLISHED_ANDESITE = "polished_andesite";
-	public const STONE_SLAB_TYPE_3_POLISHED_DIORITE = "polished_diorite";
-	public const STONE_SLAB_TYPE_3_POLISHED_GRANITE = "polished_granite";
-	public const STONE_SLAB_TYPE_3_SMOOTH_RED_SANDSTONE = "smooth_red_sandstone";
-
-	public const STONE_SLAB_TYPE_4_CUT_RED_SANDSTONE = "cut_red_sandstone";
-	public const STONE_SLAB_TYPE_4_CUT_SANDSTONE = "cut_sandstone";
-	public const STONE_SLAB_TYPE_4_MOSSY_STONE_BRICK = "mossy_stone_brick";
-	public const STONE_SLAB_TYPE_4_SMOOTH_QUARTZ = "smooth_quartz";
-	public const STONE_SLAB_TYPE_4_STONE = "stone";
-
-	public const STONE_TYPE_ANDESITE = "andesite";
-	public const STONE_TYPE_ANDESITE_SMOOTH = "andesite_smooth";
-	public const STONE_TYPE_DIORITE = "diorite";
-	public const STONE_TYPE_DIORITE_SMOOTH = "diorite_smooth";
-	public const STONE_TYPE_GRANITE = "granite";
-	public const STONE_TYPE_GRANITE_SMOOTH = "granite_smooth";
-	public const STONE_TYPE_STONE = "stone";
-
 	public const STRUCTURE_BLOCK_TYPE_CORNER = "corner";
 	public const STRUCTURE_BLOCK_TYPE_DATA = "data";
 	public const STRUCTURE_BLOCK_TYPE_EXPORT = "export";
@@ -259,11 +141,6 @@ final class BlockStateStringValues{
 	public const STRUCTURE_VOID_TYPE_AIR = "air";
 	public const STRUCTURE_VOID_TYPE_VOID = "void";
 
-	public const TALL_GRASS_TYPE_DEFAULT = "default";
-	public const TALL_GRASS_TYPE_FERN = "fern";
-	public const TALL_GRASS_TYPE_SNOW = "snow";
-	public const TALL_GRASS_TYPE_TALL = "tall";
-
 	public const TORCH_FACING_DIRECTION_EAST = "east";
 	public const TORCH_FACING_DIRECTION_NORTH = "north";
 	public const TORCH_FACING_DIRECTION_SOUTH = "south";
@@ -276,6 +153,11 @@ final class BlockStateStringValues{
 	public const TURTLE_EGG_COUNT_THREE_EGG = "three_egg";
 	public const TURTLE_EGG_COUNT_TWO_EGG = "two_egg";
 
+	public const VAULT_STATE_ACTIVE = "active";
+	public const VAULT_STATE_EJECTING = "ejecting";
+	public const VAULT_STATE_INACTIVE = "inactive";
+	public const VAULT_STATE_UNLOCKING = "unlocking";
+
 	public const WALL_BLOCK_TYPE_ANDESITE = "andesite";
 	public const WALL_BLOCK_TYPE_BRICK = "brick";
 	public const WALL_BLOCK_TYPE_COBBLESTONE = "cobblestone";
@@ -307,11 +189,4 @@ final class BlockStateStringValues{
 	public const WALL_CONNECTION_TYPE_WEST_SHORT = "short";
 	public const WALL_CONNECTION_TYPE_WEST_TALL = "tall";
 
-	public const WOOD_TYPE_ACACIA = "acacia";
-	public const WOOD_TYPE_BIRCH = "birch";
-	public const WOOD_TYPE_DARK_OAK = "dark_oak";
-	public const WOOD_TYPE_JUNGLE = "jungle";
-	public const WOOD_TYPE_OAK = "oak";
-	public const WOOD_TYPE_SPRUCE = "spruce";
-
 }

src/data/bedrock/block/BlockTypeNames.php

@@ -33,26 +33,37 @@ final class BlockTypeNames{
 
 	public const ACACIA_BUTTON = "minecraft:acacia_button";
 	public const ACACIA_DOOR = "minecraft:acacia_door";
+	public const ACACIA_DOUBLE_SLAB = "minecraft:acacia_double_slab";
 	public const ACACIA_FENCE = "minecraft:acacia_fence";
 	public const ACACIA_FENCE_GATE = "minecraft:acacia_fence_gate";
 	public const ACACIA_HANGING_SIGN = "minecraft:acacia_hanging_sign";
+	public const ACACIA_LEAVES = "minecraft:acacia_leaves";
 	public const ACACIA_LOG = "minecraft:acacia_log";
+	public const ACACIA_PLANKS = "minecraft:acacia_planks";
 	public const ACACIA_PRESSURE_PLATE = "minecraft:acacia_pressure_plate";
+	public const ACACIA_SAPLING = "minecraft:acacia_sapling";
+	public const ACACIA_SLAB = "minecraft:acacia_slab";
 	public const ACACIA_STAIRS = "minecraft:acacia_stairs";
 	public const ACACIA_STANDING_SIGN = "minecraft:acacia_standing_sign";
 	public const ACACIA_TRAPDOOR = "minecraft:acacia_trapdoor";
 	public const ACACIA_WALL_SIGN = "minecraft:acacia_wall_sign";
+	public const ACACIA_WOOD = "minecraft:acacia_wood";
 	public const ACTIVATOR_RAIL = "minecraft:activator_rail";
 	public const AIR = "minecraft:air";
+	public const ALLIUM = "minecraft:allium";
 	public const ALLOW = "minecraft:allow";
 	public const AMETHYST_BLOCK = "minecraft:amethyst_block";
 	public const AMETHYST_CLUSTER = "minecraft:amethyst_cluster";
 	public const ANCIENT_DEBRIS = "minecraft:ancient_debris";
+	public const ANDESITE = "minecraft:andesite";
+	public const ANDESITE_DOUBLE_SLAB = "minecraft:andesite_double_slab";
+	public const ANDESITE_SLAB = "minecraft:andesite_slab";
 	public const ANDESITE_STAIRS = "minecraft:andesite_stairs";
 	public const ANVIL = "minecraft:anvil";
 	public const AZALEA = "minecraft:azalea";
 	public const AZALEA_LEAVES = "minecraft:azalea_leaves";
 	public const AZALEA_LEAVES_FLOWERED = "minecraft:azalea_leaves_flowered";
+	public const AZURE_BLUET = "minecraft:azure_bluet";
 	public const BAMBOO = "minecraft:bamboo";
 	public const BAMBOO_BLOCK = "minecraft:bamboo_block";
 	public const BAMBOO_BUTTON = "minecraft:bamboo_button";
@@ -86,15 +97,21 @@ final class BlockTypeNames{
 	public const BIG_DRIPLEAF = "minecraft:big_dripleaf";
 	public const BIRCH_BUTTON = "minecraft:birch_button";
 	public const BIRCH_DOOR = "minecraft:birch_door";
+	public const BIRCH_DOUBLE_SLAB = "minecraft:birch_double_slab";
 	public const BIRCH_FENCE = "minecraft:birch_fence";
 	public const BIRCH_FENCE_GATE = "minecraft:birch_fence_gate";
 	public const BIRCH_HANGING_SIGN = "minecraft:birch_hanging_sign";
+	public const BIRCH_LEAVES = "minecraft:birch_leaves";
 	public const BIRCH_LOG = "minecraft:birch_log";
+	public const BIRCH_PLANKS = "minecraft:birch_planks";
 	public const BIRCH_PRESSURE_PLATE = "minecraft:birch_pressure_plate";
+	public const BIRCH_SAPLING = "minecraft:birch_sapling";
+	public const BIRCH_SLAB = "minecraft:birch_slab";
 	public const BIRCH_STAIRS = "minecraft:birch_stairs";
 	public const BIRCH_STANDING_SIGN = "minecraft:birch_standing_sign";
 	public const BIRCH_TRAPDOOR = "minecraft:birch_trapdoor";
 	public const BIRCH_WALL_SIGN = "minecraft:birch_wall_sign";
+	public const BIRCH_WOOD = "minecraft:birch_wood";
 	public const BLACK_CANDLE = "minecraft:black_candle";
 	public const BLACK_CANDLE_CAKE = "minecraft:black_candle_cake";
 	public const BLACK_CARPET = "minecraft:black_carpet";
@@ -119,6 +136,7 @@ final class BlockTypeNames{
 	public const BLUE_CONCRETE_POWDER = "minecraft:blue_concrete_powder";
 	public const BLUE_GLAZED_TERRACOTTA = "minecraft:blue_glazed_terracotta";
 	public const BLUE_ICE = "minecraft:blue_ice";
+	public const BLUE_ORCHID = "minecraft:blue_orchid";
 	public const BLUE_SHULKER_BOX = "minecraft:blue_shulker_box";
 	public const BLUE_STAINED_GLASS = "minecraft:blue_stained_glass";
 	public const BLUE_STAINED_GLASS_PANE = "minecraft:blue_stained_glass_pane";
@@ -128,8 +146,13 @@ final class BlockTypeNames{
 	public const BOOKSHELF = "minecraft:bookshelf";
 	public const BORDER_BLOCK = "minecraft:border_block";
 	public const BRAIN_CORAL = "minecraft:brain_coral";
+	public const BRAIN_CORAL_BLOCK = "minecraft:brain_coral_block";
+	public const BRAIN_CORAL_FAN = "minecraft:brain_coral_fan";
+	public const BRAIN_CORAL_WALL_FAN = "minecraft:brain_coral_wall_fan";
 	public const BREWING_STAND = "minecraft:brewing_stand";
 	public const BRICK_BLOCK = "minecraft:brick_block";
+	public const BRICK_DOUBLE_SLAB = "minecraft:brick_double_slab";
+	public const BRICK_SLAB = "minecraft:brick_slab";
 	public const BRICK_STAIRS = "minecraft:brick_stairs";
 	public const BROWN_CANDLE = "minecraft:brown_candle";
 	public const BROWN_CANDLE_CAKE = "minecraft:brown_candle_cake";
@@ -146,6 +169,9 @@ final class BlockTypeNames{
 	public const BROWN_WOOL = "minecraft:brown_wool";
 	public const BUBBLE_COLUMN = "minecraft:bubble_column";
 	public const BUBBLE_CORAL = "minecraft:bubble_coral";
+	public const BUBBLE_CORAL_BLOCK = "minecraft:bubble_coral_block";
+	public const BUBBLE_CORAL_FAN = "minecraft:bubble_coral_fan";
+	public const BUBBLE_CORAL_WALL_FAN = "minecraft:bubble_coral_wall_fan";
 	public const BUDDING_AMETHYST = "minecraft:budding_amethyst";
 	public const CACTUS = "minecraft:cactus";
 	public const CAKE = "minecraft:cake";
@@ -184,22 +210,33 @@ final class BlockTypeNames{
 	public const CHERRY_WALL_SIGN = "minecraft:cherry_wall_sign";
 	public const CHERRY_WOOD = "minecraft:cherry_wood";
 	public const CHEST = "minecraft:chest";
+	public const CHIPPED_ANVIL = "minecraft:chipped_anvil";
 	public const CHISELED_BOOKSHELF = "minecraft:chiseled_bookshelf";
+	public const CHISELED_COPPER = "minecraft:chiseled_copper";
 	public const CHISELED_DEEPSLATE = "minecraft:chiseled_deepslate";
 	public const CHISELED_NETHER_BRICKS = "minecraft:chiseled_nether_bricks";
 	public const CHISELED_POLISHED_BLACKSTONE = "minecraft:chiseled_polished_blackstone";
+	public const CHISELED_QUARTZ_BLOCK = "minecraft:chiseled_quartz_block";
+	public const CHISELED_RED_SANDSTONE = "minecraft:chiseled_red_sandstone";
+	public const CHISELED_SANDSTONE = "minecraft:chiseled_sandstone";
+	public const CHISELED_STONE_BRICKS = "minecraft:chiseled_stone_bricks";
+	public const CHISELED_TUFF = "minecraft:chiseled_tuff";
+	public const CHISELED_TUFF_BRICKS = "minecraft:chiseled_tuff_bricks";
 	public const CHORUS_FLOWER = "minecraft:chorus_flower";
 	public const CHORUS_PLANT = "minecraft:chorus_plant";
 	public const CLAY = "minecraft:clay";
 	public const CLIENT_REQUEST_PLACEHOLDER_BLOCK = "minecraft:client_request_placeholder_block";
 	public const COAL_BLOCK = "minecraft:coal_block";
 	public const COAL_ORE = "minecraft:coal_ore";
+	public const COARSE_DIRT = "minecraft:coarse_dirt";
 	public const COBBLED_DEEPSLATE = "minecraft:cobbled_deepslate";
 	public const COBBLED_DEEPSLATE_DOUBLE_SLAB = "minecraft:cobbled_deepslate_double_slab";
 	public const COBBLED_DEEPSLATE_SLAB = "minecraft:cobbled_deepslate_slab";
 	public const COBBLED_DEEPSLATE_STAIRS = "minecraft:cobbled_deepslate_stairs";
 	public const COBBLED_DEEPSLATE_WALL = "minecraft:cobbled_deepslate_wall";
 	public const COBBLESTONE = "minecraft:cobblestone";
+	public const COBBLESTONE_DOUBLE_SLAB = "minecraft:cobblestone_double_slab";
+	public const COBBLESTONE_SLAB = "minecraft:cobblestone_slab";
 	public const COBBLESTONE_WALL = "minecraft:cobblestone_wall";
 	public const COCOA = "minecraft:cocoa";
 	public const COLORED_TORCH_BP = "minecraft:colored_torch_bp";
@@ -208,17 +245,18 @@ final class BlockTypeNames{
 	public const COMPOSTER = "minecraft:composter";
 	public const CONDUIT = "minecraft:conduit";
 	public const COPPER_BLOCK = "minecraft:copper_block";
+	public const COPPER_BULB = "minecraft:copper_bulb";
+	public const COPPER_DOOR = "minecraft:copper_door";
+	public const COPPER_GRATE = "minecraft:copper_grate";
 	public const COPPER_ORE = "minecraft:copper_ore";
-	public const CORAL_BLOCK = "minecraft:coral_block";
-	public const CORAL_FAN = "minecraft:coral_fan";
-	public const CORAL_FAN_DEAD = "minecraft:coral_fan_dead";
-	public const CORAL_FAN_HANG = "minecraft:coral_fan_hang";
-	public const CORAL_FAN_HANG2 = "minecraft:coral_fan_hang2";
-	public const CORAL_FAN_HANG3 = "minecraft:coral_fan_hang3";
+	public const COPPER_TRAPDOOR = "minecraft:copper_trapdoor";
+	public const CORNFLOWER = "minecraft:cornflower";
 	public const CRACKED_DEEPSLATE_BRICKS = "minecraft:cracked_deepslate_bricks";
 	public const CRACKED_DEEPSLATE_TILES = "minecraft:cracked_deepslate_tiles";
 	public const CRACKED_NETHER_BRICKS = "minecraft:cracked_nether_bricks";
 	public const CRACKED_POLISHED_BLACKSTONE_BRICKS = "minecraft:cracked_polished_blackstone_bricks";
+	public const CRACKED_STONE_BRICKS = "minecraft:cracked_stone_bricks";
+	public const CRAFTER = "minecraft:crafter";
 	public const CRAFTING_TABLE = "minecraft:crafting_table";
 	public const CRIMSON_BUTTON = "minecraft:crimson_button";
 	public const CRIMSON_DOOR = "minecraft:crimson_door";
@@ -242,6 +280,12 @@ final class BlockTypeNames{
 	public const CUT_COPPER = "minecraft:cut_copper";
 	public const CUT_COPPER_SLAB = "minecraft:cut_copper_slab";
 	public const CUT_COPPER_STAIRS = "minecraft:cut_copper_stairs";
+	public const CUT_RED_SANDSTONE = "minecraft:cut_red_sandstone";
+	public const CUT_RED_SANDSTONE_DOUBLE_SLAB = "minecraft:cut_red_sandstone_double_slab";
+	public const CUT_RED_SANDSTONE_SLAB = "minecraft:cut_red_sandstone_slab";
+	public const CUT_SANDSTONE = "minecraft:cut_sandstone";
+	public const CUT_SANDSTONE_DOUBLE_SLAB = "minecraft:cut_sandstone_double_slab";
+	public const CUT_SANDSTONE_SLAB = "minecraft:cut_sandstone_slab";
 	public const CYAN_CANDLE = "minecraft:cyan_candle";
 	public const CYAN_CANDLE_CAKE = "minecraft:cyan_candle_cake";
 	public const CYAN_CARPET = "minecraft:cyan_carpet";
@@ -253,25 +297,51 @@ final class BlockTypeNames{
 	public const CYAN_STAINED_GLASS_PANE = "minecraft:cyan_stained_glass_pane";
 	public const CYAN_TERRACOTTA = "minecraft:cyan_terracotta";
 	public const CYAN_WOOL = "minecraft:cyan_wool";
+	public const DAMAGED_ANVIL = "minecraft:damaged_anvil";
+	public const DANDELION = "minecraft:dandelion";
 	public const DARK_OAK_BUTTON = "minecraft:dark_oak_button";
 	public const DARK_OAK_DOOR = "minecraft:dark_oak_door";
+	public const DARK_OAK_DOUBLE_SLAB = "minecraft:dark_oak_double_slab";
 	public const DARK_OAK_FENCE = "minecraft:dark_oak_fence";
 	public const DARK_OAK_FENCE_GATE = "minecraft:dark_oak_fence_gate";
 	public const DARK_OAK_HANGING_SIGN = "minecraft:dark_oak_hanging_sign";
+	public const DARK_OAK_LEAVES = "minecraft:dark_oak_leaves";
 	public const DARK_OAK_LOG = "minecraft:dark_oak_log";
+	public const DARK_OAK_PLANKS = "minecraft:dark_oak_planks";
 	public const DARK_OAK_PRESSURE_PLATE = "minecraft:dark_oak_pressure_plate";
+	public const DARK_OAK_SAPLING = "minecraft:dark_oak_sapling";
+	public const DARK_OAK_SLAB = "minecraft:dark_oak_slab";
 	public const DARK_OAK_STAIRS = "minecraft:dark_oak_stairs";
 	public const DARK_OAK_TRAPDOOR = "minecraft:dark_oak_trapdoor";
+	public const DARK_OAK_WOOD = "minecraft:dark_oak_wood";
+	public const DARK_PRISMARINE = "minecraft:dark_prismarine";
+	public const DARK_PRISMARINE_DOUBLE_SLAB = "minecraft:dark_prismarine_double_slab";
+	public const DARK_PRISMARINE_SLAB = "minecraft:dark_prismarine_slab";
 	public const DARK_PRISMARINE_STAIRS = "minecraft:dark_prismarine_stairs";
 	public const DARKOAK_STANDING_SIGN = "minecraft:darkoak_standing_sign";
 	public const DARKOAK_WALL_SIGN = "minecraft:darkoak_wall_sign";
 	public const DAYLIGHT_DETECTOR = "minecraft:daylight_detector";
 	public const DAYLIGHT_DETECTOR_INVERTED = "minecraft:daylight_detector_inverted";
 	public const DEAD_BRAIN_CORAL = "minecraft:dead_brain_coral";
+	public const DEAD_BRAIN_CORAL_BLOCK = "minecraft:dead_brain_coral_block";
+	public const DEAD_BRAIN_CORAL_FAN = "minecraft:dead_brain_coral_fan";
+	public const DEAD_BRAIN_CORAL_WALL_FAN = "minecraft:dead_brain_coral_wall_fan";
 	public const DEAD_BUBBLE_CORAL = "minecraft:dead_bubble_coral";
+	public const DEAD_BUBBLE_CORAL_BLOCK = "minecraft:dead_bubble_coral_block";
+	public const DEAD_BUBBLE_CORAL_FAN = "minecraft:dead_bubble_coral_fan";
+	public const DEAD_BUBBLE_CORAL_WALL_FAN = "minecraft:dead_bubble_coral_wall_fan";
 	public const DEAD_FIRE_CORAL = "minecraft:dead_fire_coral";
+	public const DEAD_FIRE_CORAL_BLOCK = "minecraft:dead_fire_coral_block";
+	public const DEAD_FIRE_CORAL_FAN = "minecraft:dead_fire_coral_fan";
+	public const DEAD_FIRE_CORAL_WALL_FAN = "minecraft:dead_fire_coral_wall_fan";
 	public const DEAD_HORN_CORAL = "minecraft:dead_horn_coral";
+	public const DEAD_HORN_CORAL_BLOCK = "minecraft:dead_horn_coral_block";
+	public const DEAD_HORN_CORAL_FAN = "minecraft:dead_horn_coral_fan";
+	public const DEAD_HORN_CORAL_WALL_FAN = "minecraft:dead_horn_coral_wall_fan";
 	public const DEAD_TUBE_CORAL = "minecraft:dead_tube_coral";
+	public const DEAD_TUBE_CORAL_BLOCK = "minecraft:dead_tube_coral_block";
+	public const DEAD_TUBE_CORAL_FAN = "minecraft:dead_tube_coral_fan";
+	public const DEAD_TUBE_CORAL_WALL_FAN = "minecraft:dead_tube_coral_wall_fan";
 	public const DEADBUSH = "minecraft:deadbush";
 	public const DECORATED_POT = "minecraft:decorated_pot";
 	public const DEEPSLATE = "minecraft:deepslate";
@@ -294,20 +364,18 @@ final class BlockTypeNames{
 	public const DEEPSLATE_TILE_WALL = "minecraft:deepslate_tile_wall";
 	public const DEEPSLATE_TILES = "minecraft:deepslate_tiles";
 	public const DENY = "minecraft:deny";
+	public const DEPRECATED_ANVIL = "minecraft:deprecated_anvil";
 	public const DETECTOR_RAIL = "minecraft:detector_rail";
 	public const DIAMOND_BLOCK = "minecraft:diamond_block";
 	public const DIAMOND_ORE = "minecraft:diamond_ore";
+	public const DIORITE = "minecraft:diorite";
+	public const DIORITE_DOUBLE_SLAB = "minecraft:diorite_double_slab";
+	public const DIORITE_SLAB = "minecraft:diorite_slab";
 	public const DIORITE_STAIRS = "minecraft:diorite_stairs";
 	public const DIRT = "minecraft:dirt";
 	public const DIRT_WITH_ROOTS = "minecraft:dirt_with_roots";
 	public const DISPENSER = "minecraft:dispenser";
 	public const DOUBLE_CUT_COPPER_SLAB = "minecraft:double_cut_copper_slab";
-	public const DOUBLE_PLANT = "minecraft:double_plant";
-	public const DOUBLE_STONE_BLOCK_SLAB = "minecraft:double_stone_block_slab";
-	public const DOUBLE_STONE_BLOCK_SLAB2 = "minecraft:double_stone_block_slab2";
-	public const DOUBLE_STONE_BLOCK_SLAB3 = "minecraft:double_stone_block_slab3";
-	public const DOUBLE_STONE_BLOCK_SLAB4 = "minecraft:double_stone_block_slab4";
-	public const DOUBLE_WOODEN_SLAB = "minecraft:double_wooden_slab";
 	public const DRAGON_EGG = "minecraft:dragon_egg";
 	public const DRIED_KELP_BLOCK = "minecraft:dried_kelp_block";
 	public const DRIPSTONE_BLOCK = "minecraft:dripstone_block";
@@ -441,16 +509,27 @@ final class BlockTypeNames{
 	public const END_PORTAL_FRAME = "minecraft:end_portal_frame";
 	public const END_ROD = "minecraft:end_rod";
 	public const END_STONE = "minecraft:end_stone";
+	public const END_STONE_BRICK_DOUBLE_SLAB = "minecraft:end_stone_brick_double_slab";
+	public const END_STONE_BRICK_SLAB = "minecraft:end_stone_brick_slab";
 	public const ENDER_CHEST = "minecraft:ender_chest";
+	public const EXPOSED_CHISELED_COPPER = "minecraft:exposed_chiseled_copper";
 	public const EXPOSED_COPPER = "minecraft:exposed_copper";
+	public const EXPOSED_COPPER_BULB = "minecraft:exposed_copper_bulb";
+	public const EXPOSED_COPPER_DOOR = "minecraft:exposed_copper_door";
+	public const EXPOSED_COPPER_GRATE = "minecraft:exposed_copper_grate";
+	public const EXPOSED_COPPER_TRAPDOOR = "minecraft:exposed_copper_trapdoor";
 	public const EXPOSED_CUT_COPPER = "minecraft:exposed_cut_copper";
 	public const EXPOSED_CUT_COPPER_SLAB = "minecraft:exposed_cut_copper_slab";
 	public const EXPOSED_CUT_COPPER_STAIRS = "minecraft:exposed_cut_copper_stairs";
 	public const EXPOSED_DOUBLE_CUT_COPPER_SLAB = "minecraft:exposed_double_cut_copper_slab";
 	public const FARMLAND = "minecraft:farmland";
 	public const FENCE_GATE = "minecraft:fence_gate";
+	public const FERN = "minecraft:fern";
 	public const FIRE = "minecraft:fire";
 	public const FIRE_CORAL = "minecraft:fire_coral";
+	public const FIRE_CORAL_BLOCK = "minecraft:fire_coral_block";
+	public const FIRE_CORAL_FAN = "minecraft:fire_coral_fan";
+	public const FIRE_CORAL_WALL_FAN = "minecraft:fire_coral_wall_fan";
 	public const FLETCHING_TABLE = "minecraft:fletching_table";
 	public const FLOWER_POT = "minecraft:flower_pot";
 	public const FLOWERING_AZALEA = "minecraft:flowering_azalea";
@@ -470,8 +549,11 @@ final class BlockTypeNames{
 	public const GOLD_BLOCK = "minecraft:gold_block";
 	public const GOLD_ORE = "minecraft:gold_ore";
 	public const GOLDEN_RAIL = "minecraft:golden_rail";
+	public const GRANITE = "minecraft:granite";
+	public const GRANITE_DOUBLE_SLAB = "minecraft:granite_double_slab";
+	public const GRANITE_SLAB = "minecraft:granite_slab";
 	public const GRANITE_STAIRS = "minecraft:granite_stairs";
-	public const GRASS = "minecraft:grass";
+	public const GRASS_BLOCK = "minecraft:grass_block";
 	public const GRASS_PATH = "minecraft:grass_path";
 	public const GRAVEL = "minecraft:gravel";
 	public const GRAY_CANDLE = "minecraft:gray_candle";
@@ -498,19 +580,59 @@ final class BlockTypeNames{
 	public const GREEN_WOOL = "minecraft:green_wool";
 	public const GRINDSTONE = "minecraft:grindstone";
 	public const HANGING_ROOTS = "minecraft:hanging_roots";
+	public const HARD_BLACK_STAINED_GLASS = "minecraft:hard_black_stained_glass";
+	public const HARD_BLACK_STAINED_GLASS_PANE = "minecraft:hard_black_stained_glass_pane";
+	public const HARD_BLUE_STAINED_GLASS = "minecraft:hard_blue_stained_glass";
+	public const HARD_BLUE_STAINED_GLASS_PANE = "minecraft:hard_blue_stained_glass_pane";
+	public const HARD_BROWN_STAINED_GLASS = "minecraft:hard_brown_stained_glass";
+	public const HARD_BROWN_STAINED_GLASS_PANE = "minecraft:hard_brown_stained_glass_pane";
+	public const HARD_CYAN_STAINED_GLASS = "minecraft:hard_cyan_stained_glass";
+	public const HARD_CYAN_STAINED_GLASS_PANE = "minecraft:hard_cyan_stained_glass_pane";
 	public const HARD_GLASS = "minecraft:hard_glass";
 	public const HARD_GLASS_PANE = "minecraft:hard_glass_pane";
-	public const HARD_STAINED_GLASS = "minecraft:hard_stained_glass";
-	public const HARD_STAINED_GLASS_PANE = "minecraft:hard_stained_glass_pane";
+	public const HARD_GRAY_STAINED_GLASS = "minecraft:hard_gray_stained_glass";
+	public const HARD_GRAY_STAINED_GLASS_PANE = "minecraft:hard_gray_stained_glass_pane";
+	public const HARD_GREEN_STAINED_GLASS = "minecraft:hard_green_stained_glass";
+	public const HARD_GREEN_STAINED_GLASS_PANE = "minecraft:hard_green_stained_glass_pane";
+	public const HARD_LIGHT_BLUE_STAINED_GLASS = "minecraft:hard_light_blue_stained_glass";
+	public const HARD_LIGHT_BLUE_STAINED_GLASS_PANE = "minecraft:hard_light_blue_stained_glass_pane";
+	public const HARD_LIGHT_GRAY_STAINED_GLASS = "minecraft:hard_light_gray_stained_glass";
+	public const HARD_LIGHT_GRAY_STAINED_GLASS_PANE = "minecraft:hard_light_gray_stained_glass_pane";
+	public const HARD_LIME_STAINED_GLASS = "minecraft:hard_lime_stained_glass";
+	public const HARD_LIME_STAINED_GLASS_PANE = "minecraft:hard_lime_stained_glass_pane";
+	public const HARD_MAGENTA_STAINED_GLASS = "minecraft:hard_magenta_stained_glass";
+	public const HARD_MAGENTA_STAINED_GLASS_PANE = "minecraft:hard_magenta_stained_glass_pane";
+	public const HARD_ORANGE_STAINED_GLASS = "minecraft:hard_orange_stained_glass";
+	public const HARD_ORANGE_STAINED_GLASS_PANE = "minecraft:hard_orange_stained_glass_pane";
+	public const HARD_PINK_STAINED_GLASS = "minecraft:hard_pink_stained_glass";
+	public const HARD_PINK_STAINED_GLASS_PANE = "minecraft:hard_pink_stained_glass_pane";
+	public const HARD_PURPLE_STAINED_GLASS = "minecraft:hard_purple_stained_glass";
+	public const HARD_PURPLE_STAINED_GLASS_PANE = "minecraft:hard_purple_stained_glass_pane";
+	public const HARD_RED_STAINED_GLASS = "minecraft:hard_red_stained_glass";
+	public const HARD_RED_STAINED_GLASS_PANE = "minecraft:hard_red_stained_glass_pane";
+	public const HARD_WHITE_STAINED_GLASS = "minecraft:hard_white_stained_glass";
+	public const HARD_WHITE_STAINED_GLASS_PANE = "minecraft:hard_white_stained_glass_pane";
+	public const HARD_YELLOW_STAINED_GLASS = "minecraft:hard_yellow_stained_glass";
+	public const HARD_YELLOW_STAINED_GLASS_PANE = "minecraft:hard_yellow_stained_glass_pane";
 	public const HARDENED_CLAY = "minecraft:hardened_clay";
 	public const HAY_BLOCK = "minecraft:hay_block";
+	public const HEAVY_CORE = "minecraft:heavy_core";
 	public const HEAVY_WEIGHTED_PRESSURE_PLATE = "minecraft:heavy_weighted_pressure_plate";
 	public const HONEY_BLOCK = "minecraft:honey_block";
 	public const HONEYCOMB_BLOCK = "minecraft:honeycomb_block";
 	public const HOPPER = "minecraft:hopper";
 	public const HORN_CORAL = "minecraft:horn_coral";
+	public const HORN_CORAL_BLOCK = "minecraft:horn_coral_block";
+	public const HORN_CORAL_FAN = "minecraft:horn_coral_fan";
+	public const HORN_CORAL_WALL_FAN = "minecraft:horn_coral_wall_fan";
 	public const ICE = "minecraft:ice";
+	public const INFESTED_CHISELED_STONE_BRICKS = "minecraft:infested_chiseled_stone_bricks";
+	public const INFESTED_COBBLESTONE = "minecraft:infested_cobblestone";
+	public const INFESTED_CRACKED_STONE_BRICKS = "minecraft:infested_cracked_stone_bricks";
 	public const INFESTED_DEEPSLATE = "minecraft:infested_deepslate";
+	public const INFESTED_MOSSY_STONE_BRICKS = "minecraft:infested_mossy_stone_bricks";
+	public const INFESTED_STONE = "minecraft:infested_stone";
+	public const INFESTED_STONE_BRICKS = "minecraft:infested_stone_bricks";
 	public const INFO_UPDATE = "minecraft:info_update";
 	public const INFO_UPDATE2 = "minecraft:info_update2";
 	public const INVISIBLE_BEDROCK = "minecraft:invisible_bedrock";
@@ -523,27 +645,47 @@ final class BlockTypeNames{
 	public const JUKEBOX = "minecraft:jukebox";
 	public const JUNGLE_BUTTON = "minecraft:jungle_button";
 	public const JUNGLE_DOOR = "minecraft:jungle_door";
+	public const JUNGLE_DOUBLE_SLAB = "minecraft:jungle_double_slab";
 	public const JUNGLE_FENCE = "minecraft:jungle_fence";
 	public const JUNGLE_FENCE_GATE = "minecraft:jungle_fence_gate";
 	public const JUNGLE_HANGING_SIGN = "minecraft:jungle_hanging_sign";
+	public const JUNGLE_LEAVES = "minecraft:jungle_leaves";
 	public const JUNGLE_LOG = "minecraft:jungle_log";
+	public const JUNGLE_PLANKS = "minecraft:jungle_planks";
 	public const JUNGLE_PRESSURE_PLATE = "minecraft:jungle_pressure_plate";
+	public const JUNGLE_SAPLING = "minecraft:jungle_sapling";
+	public const JUNGLE_SLAB = "minecraft:jungle_slab";
 	public const JUNGLE_STAIRS = "minecraft:jungle_stairs";
 	public const JUNGLE_STANDING_SIGN = "minecraft:jungle_standing_sign";
 	public const JUNGLE_TRAPDOOR = "minecraft:jungle_trapdoor";
 	public const JUNGLE_WALL_SIGN = "minecraft:jungle_wall_sign";
+	public const JUNGLE_WOOD = "minecraft:jungle_wood";
 	public const KELP = "minecraft:kelp";
 	public const LADDER = "minecraft:ladder";
 	public const LANTERN = "minecraft:lantern";
 	public const LAPIS_BLOCK = "minecraft:lapis_block";
 	public const LAPIS_ORE = "minecraft:lapis_ore";
 	public const LARGE_AMETHYST_BUD = "minecraft:large_amethyst_bud";
+	public const LARGE_FERN = "minecraft:large_fern";
 	public const LAVA = "minecraft:lava";
-	public const LEAVES = "minecraft:leaves";
-	public const LEAVES2 = "minecraft:leaves2";
 	public const LECTERN = "minecraft:lectern";
 	public const LEVER = "minecraft:lever";
-	public const LIGHT_BLOCK = "minecraft:light_block";
+	public const LIGHT_BLOCK_0 = "minecraft:light_block_0";
+	public const LIGHT_BLOCK_1 = "minecraft:light_block_1";
+	public const LIGHT_BLOCK_10 = "minecraft:light_block_10";
+	public const LIGHT_BLOCK_11 = "minecraft:light_block_11";
+	public const LIGHT_BLOCK_12 = "minecraft:light_block_12";
+	public const LIGHT_BLOCK_13 = "minecraft:light_block_13";
+	public const LIGHT_BLOCK_14 = "minecraft:light_block_14";
+	public const LIGHT_BLOCK_15 = "minecraft:light_block_15";
+	public const LIGHT_BLOCK_2 = "minecraft:light_block_2";
+	public const LIGHT_BLOCK_3 = "minecraft:light_block_3";
+	public const LIGHT_BLOCK_4 = "minecraft:light_block_4";
+	public const LIGHT_BLOCK_5 = "minecraft:light_block_5";
+	public const LIGHT_BLOCK_6 = "minecraft:light_block_6";
+	public const LIGHT_BLOCK_7 = "minecraft:light_block_7";
+	public const LIGHT_BLOCK_8 = "minecraft:light_block_8";
+	public const LIGHT_BLOCK_9 = "minecraft:light_block_9";
 	public const LIGHT_BLUE_CANDLE = "minecraft:light_blue_candle";
 	public const LIGHT_BLUE_CANDLE_CAKE = "minecraft:light_blue_candle_cake";
 	public const LIGHT_BLUE_CARPET = "minecraft:light_blue_carpet";
@@ -567,6 +709,8 @@ final class BlockTypeNames{
 	public const LIGHT_GRAY_WOOL = "minecraft:light_gray_wool";
 	public const LIGHT_WEIGHTED_PRESSURE_PLATE = "minecraft:light_weighted_pressure_plate";
 	public const LIGHTNING_ROD = "minecraft:lightning_rod";
+	public const LILAC = "minecraft:lilac";
+	public const LILY_OF_THE_VALLEY = "minecraft:lily_of_the_valley";
 	public const LIME_CANDLE = "minecraft:lime_candle";
 	public const LIME_CANDLE_CAKE = "minecraft:lime_candle_cake";
 	public const LIME_CARPET = "minecraft:lime_carpet";
@@ -621,12 +765,16 @@ final class BlockTypeNames{
 	public const MELON_BLOCK = "minecraft:melon_block";
 	public const MELON_STEM = "minecraft:melon_stem";
 	public const MOB_SPAWNER = "minecraft:mob_spawner";
-	public const MONSTER_EGG = "minecraft:monster_egg";
 	public const MOSS_BLOCK = "minecraft:moss_block";
 	public const MOSS_CARPET = "minecraft:moss_carpet";
 	public const MOSSY_COBBLESTONE = "minecraft:mossy_cobblestone";
+	public const MOSSY_COBBLESTONE_DOUBLE_SLAB = "minecraft:mossy_cobblestone_double_slab";
+	public const MOSSY_COBBLESTONE_SLAB = "minecraft:mossy_cobblestone_slab";
 	public const MOSSY_COBBLESTONE_STAIRS = "minecraft:mossy_cobblestone_stairs";
+	public const MOSSY_STONE_BRICK_DOUBLE_SLAB = "minecraft:mossy_stone_brick_double_slab";
+	public const MOSSY_STONE_BRICK_SLAB = "minecraft:mossy_stone_brick_slab";
 	public const MOSSY_STONE_BRICK_STAIRS = "minecraft:mossy_stone_brick_stairs";
+	public const MOSSY_STONE_BRICKS = "minecraft:mossy_stone_bricks";
 	public const MOVING_BLOCK = "minecraft:moving_block";
 	public const MUD = "minecraft:mud";
 	public const MUD_BRICK_DOUBLE_SLAB = "minecraft:mud_brick_double_slab";
@@ -637,7 +785,9 @@ final class BlockTypeNames{
 	public const MUDDY_MANGROVE_ROOTS = "minecraft:muddy_mangrove_roots";
 	public const MYCELIUM = "minecraft:mycelium";
 	public const NETHER_BRICK = "minecraft:nether_brick";
+	public const NETHER_BRICK_DOUBLE_SLAB = "minecraft:nether_brick_double_slab";
 	public const NETHER_BRICK_FENCE = "minecraft:nether_brick_fence";
+	public const NETHER_BRICK_SLAB = "minecraft:nether_brick_slab";
 	public const NETHER_BRICK_STAIRS = "minecraft:nether_brick_stairs";
 	public const NETHER_GOLD_ORE = "minecraft:nether_gold_ore";
 	public const NETHER_SPROUTS = "minecraft:nether_sprouts";
@@ -646,12 +796,20 @@ final class BlockTypeNames{
 	public const NETHERITE_BLOCK = "minecraft:netherite_block";
 	public const NETHERRACK = "minecraft:netherrack";
 	public const NETHERREACTOR = "minecraft:netherreactor";
+	public const NORMAL_STONE_DOUBLE_SLAB = "minecraft:normal_stone_double_slab";
+	public const NORMAL_STONE_SLAB = "minecraft:normal_stone_slab";
 	public const NORMAL_STONE_STAIRS = "minecraft:normal_stone_stairs";
 	public const NOTEBLOCK = "minecraft:noteblock";
+	public const OAK_DOUBLE_SLAB = "minecraft:oak_double_slab";
 	public const OAK_FENCE = "minecraft:oak_fence";
 	public const OAK_HANGING_SIGN = "minecraft:oak_hanging_sign";
+	public const OAK_LEAVES = "minecraft:oak_leaves";
 	public const OAK_LOG = "minecraft:oak_log";
+	public const OAK_PLANKS = "minecraft:oak_planks";
+	public const OAK_SAPLING = "minecraft:oak_sapling";
+	public const OAK_SLAB = "minecraft:oak_slab";
 	public const OAK_STAIRS = "minecraft:oak_stairs";
+	public const OAK_WOOD = "minecraft:oak_wood";
 	public const OBSERVER = "minecraft:observer";
 	public const OBSIDIAN = "minecraft:obsidian";
 	public const OCHRE_FROGLIGHT = "minecraft:ochre_froglight";
@@ -665,8 +823,15 @@ final class BlockTypeNames{
 	public const ORANGE_STAINED_GLASS = "minecraft:orange_stained_glass";
 	public const ORANGE_STAINED_GLASS_PANE = "minecraft:orange_stained_glass_pane";
 	public const ORANGE_TERRACOTTA = "minecraft:orange_terracotta";
+	public const ORANGE_TULIP = "minecraft:orange_tulip";
 	public const ORANGE_WOOL = "minecraft:orange_wool";
+	public const OXEYE_DAISY = "minecraft:oxeye_daisy";
+	public const OXIDIZED_CHISELED_COPPER = "minecraft:oxidized_chiseled_copper";
 	public const OXIDIZED_COPPER = "minecraft:oxidized_copper";
+	public const OXIDIZED_COPPER_BULB = "minecraft:oxidized_copper_bulb";
+	public const OXIDIZED_COPPER_DOOR = "minecraft:oxidized_copper_door";
+	public const OXIDIZED_COPPER_GRATE = "minecraft:oxidized_copper_grate";
+	public const OXIDIZED_COPPER_TRAPDOOR = "minecraft:oxidized_copper_trapdoor";
 	public const OXIDIZED_CUT_COPPER = "minecraft:oxidized_cut_copper";
 	public const OXIDIZED_CUT_COPPER_SLAB = "minecraft:oxidized_cut_copper_slab";
 	public const OXIDIZED_CUT_COPPER_STAIRS = "minecraft:oxidized_cut_copper_stairs";
@@ -674,6 +839,9 @@ final class BlockTypeNames{
 	public const PACKED_ICE = "minecraft:packed_ice";
 	public const PACKED_MUD = "minecraft:packed_mud";
 	public const PEARLESCENT_FROGLIGHT = "minecraft:pearlescent_froglight";
+	public const PEONY = "minecraft:peony";
+	public const PETRIFIED_OAK_DOUBLE_SLAB = "minecraft:petrified_oak_double_slab";
+	public const PETRIFIED_OAK_SLAB = "minecraft:petrified_oak_slab";
 	public const PINK_CANDLE = "minecraft:pink_candle";
 	public const PINK_CANDLE_CAKE = "minecraft:pink_candle_cake";
 	public const PINK_CARPET = "minecraft:pink_carpet";
@@ -685,14 +853,17 @@ final class BlockTypeNames{
 	public const PINK_STAINED_GLASS = "minecraft:pink_stained_glass";
 	public const PINK_STAINED_GLASS_PANE = "minecraft:pink_stained_glass_pane";
 	public const PINK_TERRACOTTA = "minecraft:pink_terracotta";
+	public const PINK_TULIP = "minecraft:pink_tulip";
 	public const PINK_WOOL = "minecraft:pink_wool";
 	public const PISTON = "minecraft:piston";
 	public const PISTON_ARM_COLLISION = "minecraft:piston_arm_collision";
 	public const PITCHER_CROP = "minecraft:pitcher_crop";
 	public const PITCHER_PLANT = "minecraft:pitcher_plant";
-	public const PLANKS = "minecraft:planks";
 	public const PODZOL = "minecraft:podzol";
 	public const POINTED_DRIPSTONE = "minecraft:pointed_dripstone";
+	public const POLISHED_ANDESITE = "minecraft:polished_andesite";
+	public const POLISHED_ANDESITE_DOUBLE_SLAB = "minecraft:polished_andesite_double_slab";
+	public const POLISHED_ANDESITE_SLAB = "minecraft:polished_andesite_slab";
 	public const POLISHED_ANDESITE_STAIRS = "minecraft:polished_andesite_stairs";
 	public const POLISHED_BASALT = "minecraft:polished_basalt";
 	public const POLISHED_BLACKSTONE = "minecraft:polished_blackstone";
@@ -712,15 +883,32 @@ final class BlockTypeNames{
 	public const POLISHED_DEEPSLATE_SLAB = "minecraft:polished_deepslate_slab";
 	public const POLISHED_DEEPSLATE_STAIRS = "minecraft:polished_deepslate_stairs";
 	public const POLISHED_DEEPSLATE_WALL = "minecraft:polished_deepslate_wall";
+	public const POLISHED_DIORITE = "minecraft:polished_diorite";
+	public const POLISHED_DIORITE_DOUBLE_SLAB = "minecraft:polished_diorite_double_slab";
+	public const POLISHED_DIORITE_SLAB = "minecraft:polished_diorite_slab";
 	public const POLISHED_DIORITE_STAIRS = "minecraft:polished_diorite_stairs";
+	public const POLISHED_GRANITE = "minecraft:polished_granite";
+	public const POLISHED_GRANITE_DOUBLE_SLAB = "minecraft:polished_granite_double_slab";
+	public const POLISHED_GRANITE_SLAB = "minecraft:polished_granite_slab";
 	public const POLISHED_GRANITE_STAIRS = "minecraft:polished_granite_stairs";
+	public const POLISHED_TUFF = "minecraft:polished_tuff";
+	public const POLISHED_TUFF_DOUBLE_SLAB = "minecraft:polished_tuff_double_slab";
+	public const POLISHED_TUFF_SLAB = "minecraft:polished_tuff_slab";
+	public const POLISHED_TUFF_STAIRS = "minecraft:polished_tuff_stairs";
+	public const POLISHED_TUFF_WALL = "minecraft:polished_tuff_wall";
+	public const POPPY = "minecraft:poppy";
 	public const PORTAL = "minecraft:portal";
 	public const POTATOES = "minecraft:potatoes";
 	public const POWDER_SNOW = "minecraft:powder_snow";
 	public const POWERED_COMPARATOR = "minecraft:powered_comparator";
 	public const POWERED_REPEATER = "minecraft:powered_repeater";
 	public const PRISMARINE = "minecraft:prismarine";
+	public const PRISMARINE_BRICK_DOUBLE_SLAB = "minecraft:prismarine_brick_double_slab";
+	public const PRISMARINE_BRICK_SLAB = "minecraft:prismarine_brick_slab";
+	public const PRISMARINE_BRICKS = "minecraft:prismarine_bricks";
 	public const PRISMARINE_BRICKS_STAIRS = "minecraft:prismarine_bricks_stairs";
+	public const PRISMARINE_DOUBLE_SLAB = "minecraft:prismarine_double_slab";
+	public const PRISMARINE_SLAB = "minecraft:prismarine_slab";
 	public const PRISMARINE_STAIRS = "minecraft:prismarine_stairs";
 	public const PUMPKIN = "minecraft:pumpkin";
 	public const PUMPKIN_STEM = "minecraft:pumpkin_stem";
@@ -736,10 +924,15 @@ final class BlockTypeNames{
 	public const PURPLE_TERRACOTTA = "minecraft:purple_terracotta";
 	public const PURPLE_WOOL = "minecraft:purple_wool";
 	public const PURPUR_BLOCK = "minecraft:purpur_block";
+	public const PURPUR_DOUBLE_SLAB = "minecraft:purpur_double_slab";
+	public const PURPUR_SLAB = "minecraft:purpur_slab";
 	public const PURPUR_STAIRS = "minecraft:purpur_stairs";
 	public const QUARTZ_BLOCK = "minecraft:quartz_block";
 	public const QUARTZ_BRICKS = "minecraft:quartz_bricks";
+	public const QUARTZ_DOUBLE_SLAB = "minecraft:quartz_double_slab";
 	public const QUARTZ_ORE = "minecraft:quartz_ore";
+	public const QUARTZ_PILLAR = "minecraft:quartz_pillar";
+	public const QUARTZ_SLAB = "minecraft:quartz_slab";
 	public const QUARTZ_STAIRS = "minecraft:quartz_stairs";
 	public const RAIL = "minecraft:rail";
 	public const RAW_COPPER_BLOCK = "minecraft:raw_copper_block";
@@ -750,18 +943,23 @@ final class BlockTypeNames{
 	public const RED_CARPET = "minecraft:red_carpet";
 	public const RED_CONCRETE = "minecraft:red_concrete";
 	public const RED_CONCRETE_POWDER = "minecraft:red_concrete_powder";
-	public const RED_FLOWER = "minecraft:red_flower";
 	public const RED_GLAZED_TERRACOTTA = "minecraft:red_glazed_terracotta";
 	public const RED_MUSHROOM = "minecraft:red_mushroom";
 	public const RED_MUSHROOM_BLOCK = "minecraft:red_mushroom_block";
 	public const RED_NETHER_BRICK = "minecraft:red_nether_brick";
+	public const RED_NETHER_BRICK_DOUBLE_SLAB = "minecraft:red_nether_brick_double_slab";
+	public const RED_NETHER_BRICK_SLAB = "minecraft:red_nether_brick_slab";
 	public const RED_NETHER_BRICK_STAIRS = "minecraft:red_nether_brick_stairs";
+	public const RED_SAND = "minecraft:red_sand";
 	public const RED_SANDSTONE = "minecraft:red_sandstone";
+	public const RED_SANDSTONE_DOUBLE_SLAB = "minecraft:red_sandstone_double_slab";
+	public const RED_SANDSTONE_SLAB = "minecraft:red_sandstone_slab";
 	public const RED_SANDSTONE_STAIRS = "minecraft:red_sandstone_stairs";
 	public const RED_SHULKER_BOX = "minecraft:red_shulker_box";
 	public const RED_STAINED_GLASS = "minecraft:red_stained_glass";
 	public const RED_STAINED_GLASS_PANE = "minecraft:red_stained_glass_pane";
 	public const RED_TERRACOTTA = "minecraft:red_terracotta";
+	public const RED_TULIP = "minecraft:red_tulip";
 	public const RED_WOOL = "minecraft:red_wool";
 	public const REDSTONE_BLOCK = "minecraft:redstone_block";
 	public const REDSTONE_LAMP = "minecraft:redstone_lamp";
@@ -773,10 +971,12 @@ final class BlockTypeNames{
 	public const REPEATING_COMMAND_BLOCK = "minecraft:repeating_command_block";
 	public const RESERVED6 = "minecraft:reserved6";
 	public const RESPAWN_ANCHOR = "minecraft:respawn_anchor";
+	public const ROSE_BUSH = "minecraft:rose_bush";
 	public const SAND = "minecraft:sand";
 	public const SANDSTONE = "minecraft:sandstone";
+	public const SANDSTONE_DOUBLE_SLAB = "minecraft:sandstone_double_slab";
+	public const SANDSTONE_SLAB = "minecraft:sandstone_slab";
 	public const SANDSTONE_STAIRS = "minecraft:sandstone_stairs";
-	public const SAPLING = "minecraft:sapling";
 	public const SCAFFOLDING = "minecraft:scaffolding";
 	public const SCULK = "minecraft:sculk";
 	public const SCULK_CATALYST = "minecraft:sculk_catalyst";
@@ -786,6 +986,7 @@ final class BlockTypeNames{
 	public const SEA_LANTERN = "minecraft:sea_lantern";
 	public const SEA_PICKLE = "minecraft:sea_pickle";
 	public const SEAGRASS = "minecraft:seagrass";
+	public const SHORT_GRASS = "minecraft:short_grass";
 	public const SHROOMLIGHT = "minecraft:shroomlight";
 	public const SILVER_GLAZED_TERRACOTTA = "minecraft:silver_glazed_terracotta";
 	public const SKULL = "minecraft:skull";
@@ -795,10 +996,21 @@ final class BlockTypeNames{
 	public const SMITHING_TABLE = "minecraft:smithing_table";
 	public const SMOKER = "minecraft:smoker";
 	public const SMOOTH_BASALT = "minecraft:smooth_basalt";
+	public const SMOOTH_QUARTZ = "minecraft:smooth_quartz";
+	public const SMOOTH_QUARTZ_DOUBLE_SLAB = "minecraft:smooth_quartz_double_slab";
+	public const SMOOTH_QUARTZ_SLAB = "minecraft:smooth_quartz_slab";
 	public const SMOOTH_QUARTZ_STAIRS = "minecraft:smooth_quartz_stairs";
+	public const SMOOTH_RED_SANDSTONE = "minecraft:smooth_red_sandstone";
+	public const SMOOTH_RED_SANDSTONE_DOUBLE_SLAB = "minecraft:smooth_red_sandstone_double_slab";
+	public const SMOOTH_RED_SANDSTONE_SLAB = "minecraft:smooth_red_sandstone_slab";
 	public const SMOOTH_RED_SANDSTONE_STAIRS = "minecraft:smooth_red_sandstone_stairs";
+	public const SMOOTH_SANDSTONE = "minecraft:smooth_sandstone";
+	public const SMOOTH_SANDSTONE_DOUBLE_SLAB = "minecraft:smooth_sandstone_double_slab";
+	public const SMOOTH_SANDSTONE_SLAB = "minecraft:smooth_sandstone_slab";
 	public const SMOOTH_SANDSTONE_STAIRS = "minecraft:smooth_sandstone_stairs";
 	public const SMOOTH_STONE = "minecraft:smooth_stone";
+	public const SMOOTH_STONE_DOUBLE_SLAB = "minecraft:smooth_stone_double_slab";
+	public const SMOOTH_STONE_SLAB = "minecraft:smooth_stone_slab";
 	public const SNIFFER_EGG = "minecraft:sniffer_egg";
 	public const SNOW = "minecraft:snow";
 	public const SNOW_LAYER = "minecraft:snow_layer";
@@ -812,52 +1024,63 @@ final class BlockTypeNames{
 	public const SPORE_BLOSSOM = "minecraft:spore_blossom";
 	public const SPRUCE_BUTTON = "minecraft:spruce_button";
 	public const SPRUCE_DOOR = "minecraft:spruce_door";
+	public const SPRUCE_DOUBLE_SLAB = "minecraft:spruce_double_slab";
 	public const SPRUCE_FENCE = "minecraft:spruce_fence";
 	public const SPRUCE_FENCE_GATE = "minecraft:spruce_fence_gate";
 	public const SPRUCE_HANGING_SIGN = "minecraft:spruce_hanging_sign";
+	public const SPRUCE_LEAVES = "minecraft:spruce_leaves";
 	public const SPRUCE_LOG = "minecraft:spruce_log";
+	public const SPRUCE_PLANKS = "minecraft:spruce_planks";
 	public const SPRUCE_PRESSURE_PLATE = "minecraft:spruce_pressure_plate";
+	public const SPRUCE_SAPLING = "minecraft:spruce_sapling";
+	public const SPRUCE_SLAB = "minecraft:spruce_slab";
 	public const SPRUCE_STAIRS = "minecraft:spruce_stairs";
 	public const SPRUCE_STANDING_SIGN = "minecraft:spruce_standing_sign";
 	public const SPRUCE_TRAPDOOR = "minecraft:spruce_trapdoor";
 	public const SPRUCE_WALL_SIGN = "minecraft:spruce_wall_sign";
+	public const SPRUCE_WOOD = "minecraft:spruce_wood";
 	public const STANDING_BANNER = "minecraft:standing_banner";
 	public const STANDING_SIGN = "minecraft:standing_sign";
 	public const STICKY_PISTON = "minecraft:sticky_piston";
 	public const STICKY_PISTON_ARM_COLLISION = "minecraft:sticky_piston_arm_collision";
 	public const STONE = "minecraft:stone";
-	public const STONE_BLOCK_SLAB = "minecraft:stone_block_slab";
-	public const STONE_BLOCK_SLAB2 = "minecraft:stone_block_slab2";
-	public const STONE_BLOCK_SLAB3 = "minecraft:stone_block_slab3";
-	public const STONE_BLOCK_SLAB4 = "minecraft:stone_block_slab4";
+	public const STONE_BRICK_DOUBLE_SLAB = "minecraft:stone_brick_double_slab";
+	public const STONE_BRICK_SLAB = "minecraft:stone_brick_slab";
 	public const STONE_BRICK_STAIRS = "minecraft:stone_brick_stairs";
+	public const STONE_BRICKS = "minecraft:stone_bricks";
 	public const STONE_BUTTON = "minecraft:stone_button";
 	public const STONE_PRESSURE_PLATE = "minecraft:stone_pressure_plate";
 	public const STONE_STAIRS = "minecraft:stone_stairs";
-	public const STONEBRICK = "minecraft:stonebrick";
 	public const STONECUTTER = "minecraft:stonecutter";
 	public const STONECUTTER_BLOCK = "minecraft:stonecutter_block";
 	public const STRIPPED_ACACIA_LOG = "minecraft:stripped_acacia_log";
+	public const STRIPPED_ACACIA_WOOD = "minecraft:stripped_acacia_wood";
 	public const STRIPPED_BAMBOO_BLOCK = "minecraft:stripped_bamboo_block";
 	public const STRIPPED_BIRCH_LOG = "minecraft:stripped_birch_log";
+	public const STRIPPED_BIRCH_WOOD = "minecraft:stripped_birch_wood";
 	public const STRIPPED_CHERRY_LOG = "minecraft:stripped_cherry_log";
 	public const STRIPPED_CHERRY_WOOD = "minecraft:stripped_cherry_wood";
 	public const STRIPPED_CRIMSON_HYPHAE = "minecraft:stripped_crimson_hyphae";
 	public const STRIPPED_CRIMSON_STEM = "minecraft:stripped_crimson_stem";
 	public const STRIPPED_DARK_OAK_LOG = "minecraft:stripped_dark_oak_log";
+	public const STRIPPED_DARK_OAK_WOOD = "minecraft:stripped_dark_oak_wood";
 	public const STRIPPED_JUNGLE_LOG = "minecraft:stripped_jungle_log";
+	public const STRIPPED_JUNGLE_WOOD = "minecraft:stripped_jungle_wood";
 	public const STRIPPED_MANGROVE_LOG = "minecraft:stripped_mangrove_log";
 	public const STRIPPED_MANGROVE_WOOD = "minecraft:stripped_mangrove_wood";
 	public const STRIPPED_OAK_LOG = "minecraft:stripped_oak_log";
+	public const STRIPPED_OAK_WOOD = "minecraft:stripped_oak_wood";
 	public const STRIPPED_SPRUCE_LOG = "minecraft:stripped_spruce_log";
+	public const STRIPPED_SPRUCE_WOOD = "minecraft:stripped_spruce_wood";
 	public const STRIPPED_WARPED_HYPHAE = "minecraft:stripped_warped_hyphae";
 	public const STRIPPED_WARPED_STEM = "minecraft:stripped_warped_stem";
 	public const STRUCTURE_BLOCK = "minecraft:structure_block";
 	public const STRUCTURE_VOID = "minecraft:structure_void";
+	public const SUNFLOWER = "minecraft:sunflower";
 	public const SUSPICIOUS_GRAVEL = "minecraft:suspicious_gravel";
 	public const SUSPICIOUS_SAND = "minecraft:suspicious_sand";
 	public const SWEET_BERRY_BUSH = "minecraft:sweet_berry_bush";
-	public const TALLGRASS = "minecraft:tallgrass";
+	public const TALL_GRASS = "minecraft:tall_grass";
 	public const TARGET = "minecraft:target";
 	public const TINTED_GLASS = "minecraft:tinted_glass";
 	public const TNT = "minecraft:tnt";
@@ -866,10 +1089,23 @@ final class BlockTypeNames{
 	public const TORCHFLOWER_CROP = "minecraft:torchflower_crop";
 	public const TRAPDOOR = "minecraft:trapdoor";
 	public const TRAPPED_CHEST = "minecraft:trapped_chest";
+	public const TRIAL_SPAWNER = "minecraft:trial_spawner";
 	public const TRIP_WIRE = "minecraft:trip_wire";
 	public const TRIPWIRE_HOOK = "minecraft:tripwire_hook";
 	public const TUBE_CORAL = "minecraft:tube_coral";
+	public const TUBE_CORAL_BLOCK = "minecraft:tube_coral_block";
+	public const TUBE_CORAL_FAN = "minecraft:tube_coral_fan";
+	public const TUBE_CORAL_WALL_FAN = "minecraft:tube_coral_wall_fan";
 	public const TUFF = "minecraft:tuff";
+	public const TUFF_BRICK_DOUBLE_SLAB = "minecraft:tuff_brick_double_slab";
+	public const TUFF_BRICK_SLAB = "minecraft:tuff_brick_slab";
+	public const TUFF_BRICK_STAIRS = "minecraft:tuff_brick_stairs";
+	public const TUFF_BRICK_WALL = "minecraft:tuff_brick_wall";
+	public const TUFF_BRICKS = "minecraft:tuff_bricks";
+	public const TUFF_DOUBLE_SLAB = "minecraft:tuff_double_slab";
+	public const TUFF_SLAB = "minecraft:tuff_slab";
+	public const TUFF_STAIRS = "minecraft:tuff_stairs";
+	public const TUFF_WALL = "minecraft:tuff_wall";
 	public const TURTLE_EGG = "minecraft:turtle_egg";
 	public const TWISTING_VINES = "minecraft:twisting_vines";
 	public const UNDERWATER_TORCH = "minecraft:underwater_torch";
@@ -878,6 +1114,7 @@ final class BlockTypeNames{
 	public const UNLIT_REDSTONE_TORCH = "minecraft:unlit_redstone_torch";
 	public const UNPOWERED_COMPARATOR = "minecraft:unpowered_comparator";
 	public const UNPOWERED_REPEATER = "minecraft:unpowered_repeater";
+	public const VAULT = "minecraft:vault";
 	public const VERDANT_FROGLIGHT = "minecraft:verdant_froglight";
 	public const VINE = "minecraft:vine";
 	public const WALL_BANNER = "minecraft:wall_banner";
@@ -903,27 +1140,52 @@ final class BlockTypeNames{
 	public const WARPED_WART_BLOCK = "minecraft:warped_wart_block";
 	public const WATER = "minecraft:water";
 	public const WATERLILY = "minecraft:waterlily";
+	public const WAXED_CHISELED_COPPER = "minecraft:waxed_chiseled_copper";
 	public const WAXED_COPPER = "minecraft:waxed_copper";
+	public const WAXED_COPPER_BULB = "minecraft:waxed_copper_bulb";
+	public const WAXED_COPPER_DOOR = "minecraft:waxed_copper_door";
+	public const WAXED_COPPER_GRATE = "minecraft:waxed_copper_grate";
+	public const WAXED_COPPER_TRAPDOOR = "minecraft:waxed_copper_trapdoor";
 	public const WAXED_CUT_COPPER = "minecraft:waxed_cut_copper";
 	public const WAXED_CUT_COPPER_SLAB = "minecraft:waxed_cut_copper_slab";
 	public const WAXED_CUT_COPPER_STAIRS = "minecraft:waxed_cut_copper_stairs";
 	public const WAXED_DOUBLE_CUT_COPPER_SLAB = "minecraft:waxed_double_cut_copper_slab";
+	public const WAXED_EXPOSED_CHISELED_COPPER = "minecraft:waxed_exposed_chiseled_copper";
 	public const WAXED_EXPOSED_COPPER = "minecraft:waxed_exposed_copper";
+	public const WAXED_EXPOSED_COPPER_BULB = "minecraft:waxed_exposed_copper_bulb";
+	public const WAXED_EXPOSED_COPPER_DOOR = "minecraft:waxed_exposed_copper_door";
+	public const WAXED_EXPOSED_COPPER_GRATE = "minecraft:waxed_exposed_copper_grate";
+	public const WAXED_EXPOSED_COPPER_TRAPDOOR = "minecraft:waxed_exposed_copper_trapdoor";
 	public const WAXED_EXPOSED_CUT_COPPER = "minecraft:waxed_exposed_cut_copper";
 	public const WAXED_EXPOSED_CUT_COPPER_SLAB = "minecraft:waxed_exposed_cut_copper_slab";
 	public const WAXED_EXPOSED_CUT_COPPER_STAIRS = "minecraft:waxed_exposed_cut_copper_stairs";
 	public const WAXED_EXPOSED_DOUBLE_CUT_COPPER_SLAB = "minecraft:waxed_exposed_double_cut_copper_slab";
+	public const WAXED_OXIDIZED_CHISELED_COPPER = "minecraft:waxed_oxidized_chiseled_copper";
 	public const WAXED_OXIDIZED_COPPER = "minecraft:waxed_oxidized_copper";
+	public const WAXED_OXIDIZED_COPPER_BULB = "minecraft:waxed_oxidized_copper_bulb";
+	public const WAXED_OXIDIZED_COPPER_DOOR = "minecraft:waxed_oxidized_copper_door";
+	public const WAXED_OXIDIZED_COPPER_GRATE = "minecraft:waxed_oxidized_copper_grate";
+	public const WAXED_OXIDIZED_COPPER_TRAPDOOR = "minecraft:waxed_oxidized_copper_trapdoor";
 	public const WAXED_OXIDIZED_CUT_COPPER = "minecraft:waxed_oxidized_cut_copper";
 	public const WAXED_OXIDIZED_CUT_COPPER_SLAB = "minecraft:waxed_oxidized_cut_copper_slab";
 	public const WAXED_OXIDIZED_CUT_COPPER_STAIRS = "minecraft:waxed_oxidized_cut_copper_stairs";
 	public const WAXED_OXIDIZED_DOUBLE_CUT_COPPER_SLAB = "minecraft:waxed_oxidized_double_cut_copper_slab";
+	public const WAXED_WEATHERED_CHISELED_COPPER = "minecraft:waxed_weathered_chiseled_copper";
 	public const WAXED_WEATHERED_COPPER = "minecraft:waxed_weathered_copper";
+	public const WAXED_WEATHERED_COPPER_BULB = "minecraft:waxed_weathered_copper_bulb";
+	public const WAXED_WEATHERED_COPPER_DOOR = "minecraft:waxed_weathered_copper_door";
+	public const WAXED_WEATHERED_COPPER_GRATE = "minecraft:waxed_weathered_copper_grate";
+	public const WAXED_WEATHERED_COPPER_TRAPDOOR = "minecraft:waxed_weathered_copper_trapdoor";
 	public const WAXED_WEATHERED_CUT_COPPER = "minecraft:waxed_weathered_cut_copper";
 	public const WAXED_WEATHERED_CUT_COPPER_SLAB = "minecraft:waxed_weathered_cut_copper_slab";
 	public const WAXED_WEATHERED_CUT_COPPER_STAIRS = "minecraft:waxed_weathered_cut_copper_stairs";
 	public const WAXED_WEATHERED_DOUBLE_CUT_COPPER_SLAB = "minecraft:waxed_weathered_double_cut_copper_slab";
+	public const WEATHERED_CHISELED_COPPER = "minecraft:weathered_chiseled_copper";
 	public const WEATHERED_COPPER = "minecraft:weathered_copper";
+	public const WEATHERED_COPPER_BULB = "minecraft:weathered_copper_bulb";
+	public const WEATHERED_COPPER_DOOR = "minecraft:weathered_copper_door";
+	public const WEATHERED_COPPER_GRATE = "minecraft:weathered_copper_grate";
+	public const WEATHERED_COPPER_TRAPDOOR = "minecraft:weathered_copper_trapdoor";
 	public const WEATHERED_CUT_COPPER = "minecraft:weathered_cut_copper";
 	public const WEATHERED_CUT_COPPER_SLAB = "minecraft:weathered_cut_copper_slab";
 	public const WEATHERED_CUT_COPPER_STAIRS = "minecraft:weathered_cut_copper_stairs";
@@ -941,19 +1203,17 @@ final class BlockTypeNames{
 	public const WHITE_STAINED_GLASS = "minecraft:white_stained_glass";
 	public const WHITE_STAINED_GLASS_PANE = "minecraft:white_stained_glass_pane";
 	public const WHITE_TERRACOTTA = "minecraft:white_terracotta";
+	public const WHITE_TULIP = "minecraft:white_tulip";
 	public const WHITE_WOOL = "minecraft:white_wool";
 	public const WITHER_ROSE = "minecraft:wither_rose";
-	public const WOOD = "minecraft:wood";
 	public const WOODEN_BUTTON = "minecraft:wooden_button";
 	public const WOODEN_DOOR = "minecraft:wooden_door";
 	public const WOODEN_PRESSURE_PLATE = "minecraft:wooden_pressure_plate";
-	public const WOODEN_SLAB = "minecraft:wooden_slab";
 	public const YELLOW_CANDLE = "minecraft:yellow_candle";
 	public const YELLOW_CANDLE_CAKE = "minecraft:yellow_candle_cake";
 	public const YELLOW_CARPET = "minecraft:yellow_carpet";
 	public const YELLOW_CONCRETE = "minecraft:yellow_concrete";
 	public const YELLOW_CONCRETE_POWDER = "minecraft:yellow_concrete_powder";
-	public const YELLOW_FLOWER = "minecraft:yellow_flower";
 	public const YELLOW_GLAZED_TERRACOTTA = "minecraft:yellow_glazed_terracotta";
 	public const YELLOW_SHULKER_BOX = "minecraft:yellow_shulker_box";
 	public const YELLOW_STAINED_GLASS = "minecraft:yellow_stained_glass";

src/data/bedrock/block/convert/BlockObjectToStateSerializer.php

@@ -203,8 +203,8 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->registerFlatCoralSerializers();
 		$this->registerCauldronSerializers();
 		$this->registerFlatWoodBlockSerializers();
-		$this->registerLegacyWoodBlockSerializers();
 		$this->registerLeavesSerializers();
+		$this->registerSaplingSerializers();
 		$this->registerSimpleSerializers();
 		$this->registerSerializers();
 	}
@@ -315,6 +315,44 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 	}
 
 	public function registerFlatColorBlockSerializers() : void{
+		$this->map(Blocks::STAINED_HARDENED_GLASS(), fn(StainedHardenedGlass $block) => Writer::create(match($block->getColor()){
+			DyeColor::BLACK => Ids::HARD_BLACK_STAINED_GLASS,
+			DyeColor::BLUE => Ids::HARD_BLUE_STAINED_GLASS,
+			DyeColor::BROWN => Ids::HARD_BROWN_STAINED_GLASS,
+			DyeColor::CYAN => Ids::HARD_CYAN_STAINED_GLASS,
+			DyeColor::GRAY => Ids::HARD_GRAY_STAINED_GLASS,
+			DyeColor::GREEN => Ids::HARD_GREEN_STAINED_GLASS,
+			DyeColor::LIGHT_BLUE => Ids::HARD_LIGHT_BLUE_STAINED_GLASS,
+			DyeColor::LIGHT_GRAY => Ids::HARD_LIGHT_GRAY_STAINED_GLASS,
+			DyeColor::LIME => Ids::HARD_LIME_STAINED_GLASS,
+			DyeColor::MAGENTA => Ids::HARD_MAGENTA_STAINED_GLASS,
+			DyeColor::ORANGE => Ids::HARD_ORANGE_STAINED_GLASS,
+			DyeColor::PINK => Ids::HARD_PINK_STAINED_GLASS,
+			DyeColor::PURPLE => Ids::HARD_PURPLE_STAINED_GLASS,
+			DyeColor::RED => Ids::HARD_RED_STAINED_GLASS,
+			DyeColor::WHITE => Ids::HARD_WHITE_STAINED_GLASS,
+			DyeColor::YELLOW => Ids::HARD_YELLOW_STAINED_GLASS,
+		}));
+
+		$this->map(Blocks::STAINED_HARDENED_GLASS_PANE(), fn(StainedHardenedGlassPane $block) => Writer::create(match($block->getColor()){
+			DyeColor::BLACK => Ids::HARD_BLACK_STAINED_GLASS_PANE,
+			DyeColor::BLUE => Ids::HARD_BLUE_STAINED_GLASS_PANE,
+			DyeColor::BROWN => Ids::HARD_BROWN_STAINED_GLASS_PANE,
+			DyeColor::CYAN => Ids::HARD_CYAN_STAINED_GLASS_PANE,
+			DyeColor::GRAY => Ids::HARD_GRAY_STAINED_GLASS_PANE,
+			DyeColor::GREEN => Ids::HARD_GREEN_STAINED_GLASS_PANE,
+			DyeColor::LIGHT_BLUE => Ids::HARD_LIGHT_BLUE_STAINED_GLASS_PANE,
+			DyeColor::LIGHT_GRAY => Ids::HARD_LIGHT_GRAY_STAINED_GLASS_PANE,
+			DyeColor::LIME => Ids::HARD_LIME_STAINED_GLASS_PANE,
+			DyeColor::MAGENTA => Ids::HARD_MAGENTA_STAINED_GLASS_PANE,
+			DyeColor::ORANGE => Ids::HARD_ORANGE_STAINED_GLASS_PANE,
+			DyeColor::PINK => Ids::HARD_PINK_STAINED_GLASS_PANE,
+			DyeColor::PURPLE => Ids::HARD_PURPLE_STAINED_GLASS_PANE,
+			DyeColor::RED => Ids::HARD_RED_STAINED_GLASS_PANE,
+			DyeColor::WHITE => Ids::HARD_WHITE_STAINED_GLASS_PANE,
+			DyeColor::YELLOW => Ids::HARD_YELLOW_STAINED_GLASS_PANE,
+		}));
+
 		$this->map(Blocks::GLAZED_TERRACOTTA(), function(GlazedTerracotta $block) : Writer{
 			return Writer::create(match($block->getColor()){
 				DyeColor::BLACK => Ids::BLACK_GLAZED_TERRACOTTA,
@@ -500,6 +538,41 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				CoralType::TUBE => $block->isDead() ? Ids::DEAD_TUBE_CORAL : Ids::TUBE_CORAL,
 			}
 		));
+
+		$this->map(Blocks::CORAL_FAN(), fn(FloorCoralFan $block) => Writer::create(
+			match($block->getCoralType()){
+				CoralType::BRAIN => $block->isDead() ? Ids::DEAD_BRAIN_CORAL_FAN : Ids::BRAIN_CORAL_FAN,
+				CoralType::BUBBLE => $block->isDead() ? Ids::DEAD_BUBBLE_CORAL_FAN : Ids::BUBBLE_CORAL_FAN,
+				CoralType::FIRE => $block->isDead() ? Ids::DEAD_FIRE_CORAL_FAN : Ids::FIRE_CORAL_FAN,
+				CoralType::HORN => $block->isDead() ? Ids::DEAD_HORN_CORAL_FAN : Ids::HORN_CORAL_FAN,
+				CoralType::TUBE => $block->isDead() ? Ids::DEAD_TUBE_CORAL_FAN : Ids::TUBE_CORAL_FAN,
+			})
+			->writeInt(StateNames::CORAL_FAN_DIRECTION, match($axis = $block->getAxis()){
+				Axis::X => 0,
+				Axis::Z => 1,
+				default => throw new BlockStateSerializeException("Invalid axis {$axis}"),
+			}));
+
+		$this->map(Blocks::CORAL_BLOCK(), fn(CoralBlock $block) => Writer::create(
+			match($block->getCoralType()){
+				CoralType::BRAIN => $block->isDead() ? Ids::DEAD_BRAIN_CORAL_BLOCK : Ids::BRAIN_CORAL_BLOCK,
+				CoralType::BUBBLE => $block->isDead() ? Ids::DEAD_BUBBLE_CORAL_BLOCK : Ids::BUBBLE_CORAL_BLOCK,
+				CoralType::FIRE => $block->isDead() ? Ids::DEAD_FIRE_CORAL_BLOCK : Ids::FIRE_CORAL_BLOCK,
+				CoralType::HORN => $block->isDead() ? Ids::DEAD_HORN_CORAL_BLOCK : Ids::HORN_CORAL_BLOCK,
+				CoralType::TUBE => $block->isDead() ? Ids::DEAD_TUBE_CORAL_BLOCK : Ids::TUBE_CORAL_BLOCK,
+			}
+		));
+
+		$this->map(Blocks::WALL_CORAL_FAN(), fn(WallCoralFan $block) => Writer::create(
+			match($block->getCoralType()){
+				CoralType::TUBE => $block->isDead() ? Ids::DEAD_TUBE_CORAL_WALL_FAN : Ids::TUBE_CORAL_WALL_FAN,
+				CoralType::BRAIN => $block->isDead() ? Ids::DEAD_BRAIN_CORAL_WALL_FAN : Ids::BRAIN_CORAL_WALL_FAN,
+				CoralType::BUBBLE => $block->isDead() ? Ids::DEAD_BUBBLE_CORAL_WALL_FAN : Ids::BUBBLE_CORAL_WALL_FAN,
+				CoralType::FIRE => $block->isDead() ? Ids::DEAD_FIRE_CORAL_WALL_FAN : Ids::FIRE_CORAL_WALL_FAN,
+				CoralType::HORN => $block->isDead() ? Ids::DEAD_HORN_CORAL_WALL_FAN : Ids::HORN_CORAL_WALL_FAN,
+			})
+			->writeCoralFacing($block->getFacing())
+		);
 	}
 
 	private function registerCauldronSerializers() : void{
@@ -520,8 +593,10 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->map(Blocks::ACACIA_TRAPDOOR(), fn(WoodenTrapdoor $block) => Helper::encodeTrapdoor($block, new Writer(Ids::ACACIA_TRAPDOOR)));
 		$this->map(Blocks::ACACIA_WALL_SIGN(), fn(WallSign $block) => Helper::encodeWallSign($block, new Writer(Ids::ACACIA_WALL_SIGN)));
 		$this->mapLog(Blocks::ACACIA_LOG(), Ids::ACACIA_LOG, Ids::STRIPPED_ACACIA_LOG);
+		$this->mapLog(Blocks::ACACIA_WOOD(), Ids::ACACIA_WOOD, Ids::STRIPPED_ACACIA_WOOD);
 		$this->mapSimple(Blocks::ACACIA_FENCE(), Ids::ACACIA_FENCE);
-		//wood, planks and slabs still use the old way of storing wood type
+		$this->mapSimple(Blocks::ACACIA_PLANKS(), Ids::ACACIA_PLANKS);
+		$this->mapSlab(Blocks::ACACIA_SLAB(), Ids::ACACIA_SLAB, Ids::ACACIA_DOUBLE_SLAB);
 
 		$this->map(Blocks::BIRCH_BUTTON(), fn(WoodenButton $block) => Helper::encodeButton($block, new Writer(Ids::BIRCH_BUTTON)));
 		$this->map(Blocks::BIRCH_DOOR(), fn(WoodenDoor $block) => Helper::encodeDoor($block, new Writer(Ids::BIRCH_DOOR)));
@@ -531,9 +606,11 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->map(Blocks::BIRCH_TRAPDOOR(), fn(WoodenTrapdoor $block) => Helper::encodeTrapdoor($block, new Writer(Ids::BIRCH_TRAPDOOR)));
 		$this->map(Blocks::BIRCH_WALL_SIGN(), fn(WallSign $block) => Helper::encodeWallSign($block, new Writer(Ids::BIRCH_WALL_SIGN)));
 		$this->mapLog(Blocks::BIRCH_LOG(), Ids::BIRCH_LOG, Ids::STRIPPED_BIRCH_LOG);
+		$this->mapLog(Blocks::BIRCH_WOOD(), Ids::BIRCH_WOOD, Ids::STRIPPED_BIRCH_WOOD);
 		$this->mapSimple(Blocks::BIRCH_FENCE(), Ids::BIRCH_FENCE);
+		$this->mapSimple(Blocks::BIRCH_PLANKS(), Ids::BIRCH_PLANKS);
+		$this->mapSlab(Blocks::BIRCH_SLAB(), Ids::BIRCH_SLAB, Ids::BIRCH_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::BIRCH_STAIRS(), Ids::BIRCH_STAIRS);
-		//wood, planks and slabs still use the old way of storing wood type
 
 		$this->map(Blocks::CHERRY_BUTTON(), fn(Button $block) => Helper::encodeButton($block, new Writer(Ids::CHERRY_BUTTON)));
 		$this->map(Blocks::CHERRY_DOOR(), fn(Door $block) => Helper::encodeDoor($block, new Writer(Ids::CHERRY_DOOR)));
@@ -581,9 +658,11 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->map(Blocks::DARK_OAK_TRAPDOOR(), fn(WoodenTrapdoor $block) => Helper::encodeTrapdoor($block, new Writer(Ids::DARK_OAK_TRAPDOOR)));
 		$this->map(Blocks::DARK_OAK_WALL_SIGN(), fn(WallSign $block) => Helper::encodeWallSign($block, new Writer(Ids::DARKOAK_WALL_SIGN)));
 		$this->mapLog(Blocks::DARK_OAK_LOG(), Ids::DARK_OAK_LOG, Ids::STRIPPED_DARK_OAK_LOG);
+		$this->mapLog(Blocks::DARK_OAK_WOOD(), Ids::DARK_OAK_WOOD, Ids::STRIPPED_DARK_OAK_WOOD);
 		$this->mapSimple(Blocks::DARK_OAK_FENCE(), Ids::DARK_OAK_FENCE);
+		$this->mapSimple(Blocks::DARK_OAK_PLANKS(), Ids::DARK_OAK_PLANKS);
+		$this->mapSlab(Blocks::DARK_OAK_SLAB(), Ids::DARK_OAK_SLAB, Ids::DARK_OAK_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::DARK_OAK_STAIRS(), Ids::DARK_OAK_STAIRS);
-		//wood, planks and slabs still use the old way of storing wood type
 
 		$this->map(Blocks::JUNGLE_BUTTON(), fn(WoodenButton $block) => Helper::encodeButton($block, new Writer(Ids::JUNGLE_BUTTON)));
 		$this->map(Blocks::JUNGLE_DOOR(), fn(WoodenDoor $block) => Helper::encodeDoor($block, new Writer(Ids::JUNGLE_DOOR)));
@@ -593,9 +672,11 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->map(Blocks::JUNGLE_TRAPDOOR(), fn(WoodenTrapdoor $block) => Helper::encodeTrapdoor($block, new Writer(Ids::JUNGLE_TRAPDOOR)));
 		$this->map(Blocks::JUNGLE_WALL_SIGN(), fn(WallSign $block) => Helper::encodeWallSign($block, new Writer(Ids::JUNGLE_WALL_SIGN)));
 		$this->mapLog(Blocks::JUNGLE_LOG(), Ids::JUNGLE_LOG, Ids::STRIPPED_JUNGLE_LOG);
+		$this->mapLog(Blocks::JUNGLE_WOOD(), Ids::JUNGLE_WOOD, Ids::STRIPPED_JUNGLE_WOOD);
 		$this->mapSimple(Blocks::JUNGLE_FENCE(), Ids::JUNGLE_FENCE);
+		$this->mapSimple(Blocks::JUNGLE_PLANKS(), Ids::JUNGLE_PLANKS);
+		$this->mapSlab(Blocks::JUNGLE_SLAB(), Ids::JUNGLE_SLAB, Ids::JUNGLE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::JUNGLE_STAIRS(), Ids::JUNGLE_STAIRS);
-		//wood, planks and slabs still use the old way of storing wood type
 
 		$this->map(Blocks::MANGROVE_BUTTON(), fn(Button $block) => Helper::encodeButton($block, new Writer(Ids::MANGROVE_BUTTON)));
 		$this->map(Blocks::MANGROVE_DOOR(), fn(Door $block) => Helper::encodeDoor($block, new Writer(Ids::MANGROVE_DOOR)));
@@ -629,21 +710,26 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->map(Blocks::OAK_TRAPDOOR(), fn(WoodenTrapdoor $block) => Helper::encodeTrapdoor($block, new Writer(Ids::TRAPDOOR)));
 		$this->map(Blocks::OAK_WALL_SIGN(), fn(WallSign $block) => Helper::encodeWallSign($block, new Writer(Ids::WALL_SIGN)));
 		$this->mapLog(Blocks::OAK_LOG(), Ids::OAK_LOG, Ids::STRIPPED_OAK_LOG);
+		$this->mapLog(Blocks::OAK_WOOD(), Ids::OAK_WOOD, Ids::STRIPPED_OAK_WOOD);
 		$this->mapSimple(Blocks::OAK_FENCE(), Ids::OAK_FENCE);
+		$this->mapSimple(Blocks::OAK_PLANKS(), Ids::OAK_PLANKS);
+		$this->mapSlab(Blocks::OAK_SLAB(), Ids::OAK_SLAB, Ids::OAK_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::OAK_STAIRS(), Ids::OAK_STAIRS);
-		//wood, planks and slabs still use the old way of storing wood type
 
-		$this->mapSimple(Blocks::SPRUCE_FENCE(), Ids::SPRUCE_FENCE);
-		$this->mapLog(Blocks::SPRUCE_LOG(), Ids::SPRUCE_LOG, Ids::STRIPPED_SPRUCE_LOG);
 		$this->map(Blocks::SPRUCE_BUTTON(), fn(WoodenButton $block) => Helper::encodeButton($block, new Writer(Ids::SPRUCE_BUTTON)));
 		$this->map(Blocks::SPRUCE_DOOR(), fn(WoodenDoor $block) => Helper::encodeDoor($block, new Writer(Ids::SPRUCE_DOOR)));
 		$this->map(Blocks::SPRUCE_FENCE_GATE(), fn(FenceGate $block) => Helper::encodeFenceGate($block, new Writer(Ids::SPRUCE_FENCE_GATE)));
 		$this->map(Blocks::SPRUCE_PRESSURE_PLATE(), fn(WoodenPressurePlate $block) => Helper::encodeSimplePressurePlate($block, new Writer(Ids::SPRUCE_PRESSURE_PLATE)));
 		$this->map(Blocks::SPRUCE_SIGN(), fn(FloorSign $block) => Helper::encodeFloorSign($block, new Writer(Ids::SPRUCE_STANDING_SIGN)));
-		$this->mapStairs(Blocks::SPRUCE_STAIRS(), Ids::SPRUCE_STAIRS);
 		$this->map(Blocks::SPRUCE_TRAPDOOR(), fn(WoodenTrapdoor $block) => Helper::encodeTrapdoor($block, new Writer(Ids::SPRUCE_TRAPDOOR)));
 		$this->map(Blocks::SPRUCE_WALL_SIGN(), fn(WallSign $block) => Helper::encodeWallSign($block, new Writer(Ids::SPRUCE_WALL_SIGN)));
-		//wood, planks and slabs still use the old way of storing wood type
+		$this->mapLog(Blocks::SPRUCE_LOG(), Ids::SPRUCE_LOG, Ids::STRIPPED_SPRUCE_LOG);
+		$this->mapLog(Blocks::SPRUCE_WOOD(), Ids::SPRUCE_WOOD, Ids::STRIPPED_SPRUCE_WOOD);
+		$this->mapSimple(Blocks::SPRUCE_FENCE(), Ids::SPRUCE_FENCE);
+		$this->mapSimple(Blocks::SPRUCE_PLANKS(), Ids::SPRUCE_PLANKS);
+		$this->mapSlab(Blocks::SPRUCE_SLAB(), Ids::SPRUCE_SLAB, Ids::SPRUCE_DOUBLE_SLAB);
+		$this->mapStairs(Blocks::SPRUCE_STAIRS(), Ids::SPRUCE_STAIRS);
+		//wood and slabs still use the old way of storing wood type
 
 		$this->map(Blocks::WARPED_BUTTON(), fn(Button $block) => Helper::encodeButton($block, new Writer(Ids::WARPED_BUTTON)));
 		$this->map(Blocks::WARPED_DOOR(), fn(Door $block) => Helper::encodeDoor($block, new Writer(Ids::WARPED_DOOR)));
@@ -660,42 +746,6 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapStairs(Blocks::WARPED_STAIRS(), Ids::WARPED_STAIRS);
 	}
 
-	private function registerLegacyWoodBlockSerializers() : void{
-		foreach([
-			StringValues::WOOD_TYPE_ACACIA => Blocks::ACACIA_PLANKS(),
-			StringValues::WOOD_TYPE_BIRCH => Blocks::BIRCH_PLANKS(),
-			StringValues::WOOD_TYPE_DARK_OAK => Blocks::DARK_OAK_PLANKS(),
-			StringValues::WOOD_TYPE_JUNGLE => Blocks::JUNGLE_PLANKS(),
-			StringValues::WOOD_TYPE_OAK => Blocks::OAK_PLANKS(),
-			StringValues::WOOD_TYPE_SPRUCE => Blocks::SPRUCE_PLANKS(),
-		] as $woodType => $block){
-			$this->map($block, fn() => Writer::create(Ids::PLANKS)
-				->writeString(StateNames::WOOD_TYPE, $woodType));
-		}
-
-		foreach([
-			StringValues::WOOD_TYPE_ACACIA => Blocks::ACACIA_SLAB(),
-			StringValues::WOOD_TYPE_BIRCH => Blocks::BIRCH_SLAB(),
-			StringValues::WOOD_TYPE_DARK_OAK => Blocks::DARK_OAK_SLAB(),
-			StringValues::WOOD_TYPE_JUNGLE => Blocks::JUNGLE_SLAB(),
-			StringValues::WOOD_TYPE_OAK => Blocks::OAK_SLAB(),
-			StringValues::WOOD_TYPE_SPRUCE => Blocks::SPRUCE_SLAB(),
-		] as $woodType => $block){
-			$this->map($block, fn(Slab $block) => Helper::encodeWoodenSlab($block, $woodType));
-		}
-
-		foreach([
-			Blocks::ACACIA_WOOD(),
-			Blocks::BIRCH_WOOD(),
-			Blocks::DARK_OAK_WOOD(),
-			Blocks::JUNGLE_WOOD(),
-			Blocks::OAK_WOOD(),
-			Blocks::SPRUCE_WOOD(),
-		] as $block){
-			$this->map($block, fn(Wood $block) => Helper::encodeAllSidedLog($block));
-		}
-	}
-
 	private function registerLeavesSerializers() : void{
 		//flattened IDs
 		$this->map(Blocks::AZALEA_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves($block, new Writer(Ids::AZALEA_LEAVES)));
@@ -704,18 +754,32 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->map(Blocks::MANGROVE_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves($block, new Writer(Ids::MANGROVE_LEAVES)));
 
 		//legacy mess
-		$this->map(Blocks::ACACIA_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves2($block, StringValues::NEW_LEAF_TYPE_ACACIA));
-		$this->map(Blocks::BIRCH_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves1($block, StringValues::OLD_LEAF_TYPE_BIRCH));
-		$this->map(Blocks::DARK_OAK_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves2($block, StringValues::NEW_LEAF_TYPE_DARK_OAK));
-		$this->map(Blocks::JUNGLE_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves1($block, StringValues::OLD_LEAF_TYPE_JUNGLE));
-		$this->map(Blocks::OAK_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves1($block, StringValues::OLD_LEAF_TYPE_OAK));
-		$this->map(Blocks::SPRUCE_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves1($block, StringValues::OLD_LEAF_TYPE_SPRUCE));
+		$this->map(Blocks::ACACIA_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves($block, new Writer(Ids::ACACIA_LEAVES)));
+		$this->map(Blocks::BIRCH_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves($block, new Writer(Ids::BIRCH_LEAVES)));
+		$this->map(Blocks::DARK_OAK_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves($block, new Writer(Ids::DARK_OAK_LEAVES)));
+		$this->map(Blocks::JUNGLE_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves($block, new Writer(Ids::JUNGLE_LEAVES)));
+		$this->map(Blocks::OAK_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves($block, new Writer(Ids::OAK_LEAVES)));
+		$this->map(Blocks::SPRUCE_LEAVES(), fn(Leaves $block) => Helper::encodeLeaves($block, new Writer(Ids::SPRUCE_LEAVES)));
+	}
+
+	private function registerSaplingSerializers() : void{
+		foreach([
+			Ids::ACACIA_SAPLING => Blocks::ACACIA_SAPLING(),
+			Ids::BIRCH_SAPLING => Blocks::BIRCH_SAPLING(),
+			Ids::DARK_OAK_SAPLING => Blocks::DARK_OAK_SAPLING(),
+			Ids::JUNGLE_SAPLING => Blocks::JUNGLE_SAPLING(),
+			Ids::OAK_SAPLING => Blocks::OAK_SAPLING(),
+			Ids::SPRUCE_SAPLING => Blocks::SPRUCE_SAPLING(),
+		] as $id => $block){
+			$this->map($block, fn(Sapling $block) => Helper::encodeSapling($block, new Writer($id)));
+		}
 	}
 
 	private function registerSimpleSerializers() : void{
 		$this->mapSimple(Blocks::AIR(), Ids::AIR);
 		$this->mapSimple(Blocks::AMETHYST(), Ids::AMETHYST_BLOCK);
 		$this->mapSimple(Blocks::ANCIENT_DEBRIS(), Ids::ANCIENT_DEBRIS);
+		$this->mapSimple(Blocks::ANDESITE(), Ids::ANDESITE);
 		$this->mapSimple(Blocks::BARRIER(), Ids::BARRIER);
 		$this->mapSimple(Blocks::BEACON(), Ids::BEACON);
 		$this->mapSimple(Blocks::BLACKSTONE(), Ids::BLACKSTONE);
@@ -730,6 +794,9 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::CHISELED_DEEPSLATE(), Ids::CHISELED_DEEPSLATE);
 		$this->mapSimple(Blocks::CHISELED_NETHER_BRICKS(), Ids::CHISELED_NETHER_BRICKS);
 		$this->mapSimple(Blocks::CHISELED_POLISHED_BLACKSTONE(), Ids::CHISELED_POLISHED_BLACKSTONE);
+		$this->mapSimple(Blocks::CHISELED_RED_SANDSTONE(), Ids::CHISELED_RED_SANDSTONE);
+		$this->mapSimple(Blocks::CHISELED_SANDSTONE(), Ids::CHISELED_SANDSTONE);
+		$this->mapSimple(Blocks::CHISELED_STONE_BRICKS(), Ids::CHISELED_STONE_BRICKS);
 		$this->mapSimple(Blocks::CHORUS_PLANT(), Ids::CHORUS_PLANT);
 		$this->mapSimple(Blocks::CLAY(), Ids::CLAY);
 		$this->mapSimple(Blocks::COAL(), Ids::COAL_BLOCK);
@@ -742,10 +809,14 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::CRACKED_DEEPSLATE_TILES(), Ids::CRACKED_DEEPSLATE_TILES);
 		$this->mapSimple(Blocks::CRACKED_NETHER_BRICKS(), Ids::CRACKED_NETHER_BRICKS);
 		$this->mapSimple(Blocks::CRACKED_POLISHED_BLACKSTONE_BRICKS(), Ids::CRACKED_POLISHED_BLACKSTONE_BRICKS);
+		$this->mapSimple(Blocks::CRACKED_STONE_BRICKS(), Ids::CRACKED_STONE_BRICKS);
 		$this->mapSimple(Blocks::CRAFTING_TABLE(), Ids::CRAFTING_TABLE);
 		$this->mapSimple(Blocks::CRIMSON_ROOTS(), Ids::CRIMSON_ROOTS);
 		$this->mapSimple(Blocks::CRYING_OBSIDIAN(), Ids::CRYING_OBSIDIAN);
-		$this->mapSimple(Blocks::DANDELION(), Ids::YELLOW_FLOWER);
+		$this->mapSimple(Blocks::DANDELION(), Ids::DANDELION);
+		$this->mapSimple(Blocks::CUT_RED_SANDSTONE(), Ids::CUT_RED_SANDSTONE);
+		$this->mapSimple(Blocks::CUT_SANDSTONE(), Ids::CUT_SANDSTONE);
+		$this->mapSimple(Blocks::DARK_PRISMARINE(), Ids::DARK_PRISMARINE);
 		$this->mapSimple(Blocks::DEAD_BUSH(), Ids::DEADBUSH);
 		$this->mapSimple(Blocks::DEEPSLATE_BRICKS(), Ids::DEEPSLATE_BRICKS);
 		$this->mapSimple(Blocks::DEEPSLATE_COAL_ORE(), Ids::DEEPSLATE_COAL_ORE);
@@ -758,6 +829,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::DEEPSLATE_TILES(), Ids::DEEPSLATE_TILES);
 		$this->mapSimple(Blocks::DIAMOND(), Ids::DIAMOND_BLOCK);
 		$this->mapSimple(Blocks::DIAMOND_ORE(), Ids::DIAMOND_ORE);
+		$this->mapSimple(Blocks::DIORITE(), Ids::DIORITE);
 		$this->mapSimple(Blocks::DRAGON_EGG(), Ids::DRAGON_EGG);
 		$this->mapSimple(Blocks::DRIED_KELP(), Ids::DRIED_KELP_BLOCK);
 		$this->mapSimple(Blocks::ELEMENT_ACTINIUM(), Ids::ELEMENT_89);
@@ -884,6 +956,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::ENCHANTING_TABLE(), Ids::ENCHANTING_TABLE);
 		$this->mapSimple(Blocks::END_STONE(), Ids::END_STONE);
 		$this->mapSimple(Blocks::END_STONE_BRICKS(), Ids::END_BRICKS);
+		$this->mapSimple(Blocks::FERN(), Ids::FERN);
 		$this->mapSimple(Blocks::FLETCHING_TABLE(), Ids::FLETCHING_TABLE);
 		$this->mapSimple(Blocks::GILDED_BLACKSTONE(), Ids::GILDED_BLACKSTONE);
 		$this->mapSimple(Blocks::GLASS(), Ids::GLASS);
@@ -892,7 +965,8 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::GLOWSTONE(), Ids::GLOWSTONE);
 		$this->mapSimple(Blocks::GOLD(), Ids::GOLD_BLOCK);
 		$this->mapSimple(Blocks::GOLD_ORE(), Ids::GOLD_ORE);
-		$this->mapSimple(Blocks::GRASS(), Ids::GRASS);
+		$this->mapSimple(Blocks::GRANITE(), Ids::GRANITE);
+		$this->mapSimple(Blocks::GRASS(), Ids::GRASS_BLOCK);
 		$this->mapSimple(Blocks::GRASS_PATH(), Ids::GRASS_PATH);
 		$this->mapSimple(Blocks::GRAVEL(), Ids::GRAVEL);
 		$this->mapSimple(Blocks::HANGING_ROOTS(), Ids::HANGING_ROOTS);
@@ -901,6 +975,12 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::HARDENED_GLASS_PANE(), Ids::HARD_GLASS_PANE);
 		$this->mapSimple(Blocks::HONEYCOMB(), Ids::HONEYCOMB_BLOCK);
 		$this->mapSimple(Blocks::ICE(), Ids::ICE);
+		$this->mapSimple(Blocks::INFESTED_CHISELED_STONE_BRICK(), Ids::INFESTED_CHISELED_STONE_BRICKS);
+		$this->mapSimple(Blocks::INFESTED_COBBLESTONE(), Ids::INFESTED_COBBLESTONE);
+		$this->mapSimple(Blocks::INFESTED_CRACKED_STONE_BRICK(), Ids::INFESTED_CRACKED_STONE_BRICKS);
+		$this->mapSimple(Blocks::INFESTED_MOSSY_STONE_BRICK(), Ids::INFESTED_MOSSY_STONE_BRICKS);
+		$this->mapSimple(Blocks::INFESTED_STONE(), Ids::INFESTED_STONE);
+		$this->mapSimple(Blocks::INFESTED_STONE_BRICK(), Ids::INFESTED_STONE_BRICKS);
 		$this->mapSimple(Blocks::INFO_UPDATE(), Ids::INFO_UPDATE);
 		$this->mapSimple(Blocks::INFO_UPDATE2(), Ids::INFO_UPDATE2);
 		$this->mapSimple(Blocks::INVISIBLE_BEDROCK(), Ids::INVISIBLE_BEDROCK);
@@ -917,6 +997,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::MELON(), Ids::MELON_BLOCK);
 		$this->mapSimple(Blocks::MONSTER_SPAWNER(), Ids::MOB_SPAWNER);
 		$this->mapSimple(Blocks::MOSSY_COBBLESTONE(), Ids::MOSSY_COBBLESTONE);
+		$this->mapSimple(Blocks::MOSSY_STONE_BRICKS(), Ids::MOSSY_STONE_BRICKS);
 		$this->mapSimple(Blocks::MUD(), Ids::MUD);
 		$this->mapSimple(Blocks::MUD_BRICKS(), Ids::MUD_BRICKS);
 		$this->mapSimple(Blocks::MYCELIUM(), Ids::MYCELIUM);
@@ -933,9 +1014,14 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::PACKED_ICE(), Ids::PACKED_ICE);
 		$this->mapSimple(Blocks::PACKED_MUD(), Ids::PACKED_MUD);
 		$this->mapSimple(Blocks::PODZOL(), Ids::PODZOL);
+		$this->mapSimple(Blocks::POLISHED_ANDESITE(), Ids::POLISHED_ANDESITE);
 		$this->mapSimple(Blocks::POLISHED_BLACKSTONE(), Ids::POLISHED_BLACKSTONE);
 		$this->mapSimple(Blocks::POLISHED_BLACKSTONE_BRICKS(), Ids::POLISHED_BLACKSTONE_BRICKS);
 		$this->mapSimple(Blocks::POLISHED_DEEPSLATE(), Ids::POLISHED_DEEPSLATE);
+		$this->mapSimple(Blocks::POLISHED_DIORITE(), Ids::POLISHED_DIORITE);
+		$this->mapSimple(Blocks::POLISHED_GRANITE(), Ids::POLISHED_GRANITE);
+		$this->mapSimple(Blocks::PRISMARINE(), Ids::PRISMARINE);
+		$this->mapSimple(Blocks::PRISMARINE_BRICKS(), Ids::PRISMARINE_BRICKS);
 		$this->mapSimple(Blocks::QUARTZ_BRICKS(), Ids::QUARTZ_BRICKS);
 		$this->mapSimple(Blocks::RAW_COPPER(), Ids::RAW_COPPER_BLOCK);
 		$this->mapSimple(Blocks::RAW_GOLD(), Ids::RAW_GOLD_BLOCK);
@@ -943,8 +1029,12 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::REDSTONE(), Ids::REDSTONE_BLOCK);
 		$this->mapSimple(Blocks::RED_MUSHROOM(), Ids::RED_MUSHROOM);
 		$this->mapSimple(Blocks::RED_NETHER_BRICKS(), Ids::RED_NETHER_BRICK);
+		$this->mapSimple(Blocks::RED_SAND(), Ids::RED_SAND);
+		$this->mapSimple(Blocks::RED_SANDSTONE(), Ids::RED_SANDSTONE);
 		$this->mapSimple(Blocks::REINFORCED_DEEPSLATE(), Ids::REINFORCED_DEEPSLATE);
 		$this->mapSimple(Blocks::RESERVED6(), Ids::RESERVED6);
+		$this->mapSimple(Blocks::SAND(), Ids::SAND);
+		$this->mapSimple(Blocks::SANDSTONE(), Ids::SANDSTONE);
 		$this->mapSimple(Blocks::SCULK(), Ids::SCULK);
 		$this->mapSimple(Blocks::SEA_LANTERN(), Ids::SEA_LANTERN);
 		$this->mapSimple(Blocks::SHROOMLIGHT(), Ids::SHROOMLIGHT);
@@ -952,27 +1042,42 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::SLIME(), Ids::SLIME);
 		$this->mapSimple(Blocks::SMITHING_TABLE(), Ids::SMITHING_TABLE);
 		$this->mapSimple(Blocks::SMOOTH_BASALT(), Ids::SMOOTH_BASALT);
+		$this->mapSimple(Blocks::SMOOTH_RED_SANDSTONE(), Ids::SMOOTH_RED_SANDSTONE);
+		$this->mapSimple(Blocks::SMOOTH_SANDSTONE(), Ids::SMOOTH_SANDSTONE);
 		$this->mapSimple(Blocks::SMOOTH_STONE(), Ids::SMOOTH_STONE);
 		$this->mapSimple(Blocks::SNOW(), Ids::SNOW);
 		$this->mapSimple(Blocks::SOUL_SAND(), Ids::SOUL_SAND);
 		$this->mapSimple(Blocks::SOUL_SOIL(), Ids::SOUL_SOIL);
 		$this->mapSimple(Blocks::SPORE_BLOSSOM(), Ids::SPORE_BLOSSOM);
+		$this->mapSimple(Blocks::STONE(), Ids::STONE);
+		$this->mapSimple(Blocks::STONE_BRICKS(), Ids::STONE_BRICKS);
+		$this->mapSimple(Blocks::TALL_GRASS(), Ids::SHORT_GRASS);  //no, this is not a typo - tall_grass is now the double block, just to be confusing :(
 		$this->mapSimple(Blocks::TINTED_GLASS(), Ids::TINTED_GLASS);
 		$this->mapSimple(Blocks::TORCHFLOWER(), Ids::TORCHFLOWER);
 		$this->mapSimple(Blocks::TUFF(), Ids::TUFF);
 		$this->mapSimple(Blocks::WARPED_WART_BLOCK(), Ids::WARPED_WART_BLOCK);
 		$this->mapSimple(Blocks::WARPED_ROOTS(), Ids::WARPED_ROOTS);
 		$this->mapSimple(Blocks::WITHER_ROSE(), Ids::WITHER_ROSE);
+
+		$this->mapSimple(Blocks::ALLIUM(), Ids::ALLIUM);
+		$this->mapSimple(Blocks::CORNFLOWER(), Ids::CORNFLOWER);
+		$this->mapSimple(Blocks::AZURE_BLUET(), Ids::AZURE_BLUET);
+		$this->mapSimple(Blocks::LILY_OF_THE_VALLEY(), Ids::LILY_OF_THE_VALLEY);
+		$this->mapSimple(Blocks::BLUE_ORCHID(), Ids::BLUE_ORCHID);
+		$this->mapSimple(Blocks::OXEYE_DAISY(), Ids::OXEYE_DAISY);
+		$this->mapSimple(Blocks::POPPY(), Ids::POPPY);
+		$this->mapSimple(Blocks::ORANGE_TULIP(), Ids::ORANGE_TULIP);
+		$this->mapSimple(Blocks::PINK_TULIP(), Ids::PINK_TULIP);
+		$this->mapSimple(Blocks::RED_TULIP(), Ids::RED_TULIP);
+		$this->mapSimple(Blocks::WHITE_TULIP(), Ids::WHITE_TULIP);
 	}
 
 	private function registerSerializers() : void{
-		$this->map(Blocks::ACACIA_SAPLING(), fn(Sapling $block) => Helper::encodeSapling($block, StringValues::SAPLING_TYPE_ACACIA));
 		$this->map(Blocks::ACTIVATOR_RAIL(), function(ActivatorRail $block) : Writer{
 			return Writer::create(Ids::ACTIVATOR_RAIL)
 				->writeBool(StateNames::RAIL_DATA_BIT, $block->isPowered())
 				->writeInt(StateNames::RAIL_DIRECTION, $block->getShape());
 		});
-		$this->map(Blocks::ALLIUM(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_ALLIUM));
 		$this->map(Blocks::ALL_SIDED_MUSHROOM_STEM(), fn() => Writer::create(Ids::BROWN_MUSHROOM_BLOCK)
 				->writeInt(StateNames::HUGE_MUSHROOM_BITS, BlockLegacyMetadata::MUSHROOM_BLOCK_ALL_STEM));
 		$this->map(Blocks::AMETHYST_CLUSTER(), fn(AmethystCluster $block) => Writer::create(
@@ -985,21 +1090,18 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 			})
 			->writeBlockFace($block->getFacing())
 		);
-		$this->map(Blocks::ANDESITE(), fn() => Helper::encodeStone(StringValues::STONE_TYPE_ANDESITE));
-		$this->map(Blocks::ANDESITE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab3($block, StringValues::STONE_SLAB_TYPE_3_ANDESITE));
+		$this->mapSlab(Blocks::ANDESITE_SLAB(), Ids::ANDESITE_SLAB, Ids::ANDESITE_DOUBLE_SLAB);
 		$this->map(Blocks::ANDESITE_STAIRS(), fn(Stair $block) => Helper::encodeStairs($block, new Writer(Ids::ANDESITE_STAIRS)));
 		$this->map(Blocks::ANDESITE_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_ANDESITE));
-		$this->map(Blocks::ANVIL(), function(Anvil $block) : Writer{
-			return Writer::create(Ids::ANVIL)
-				->writeCardinalHorizontalFacing($block->getFacing())
-				->writeString(StateNames::DAMAGE, match($damage = $block->getDamage()){
-					0 => StringValues::DAMAGE_UNDAMAGED,
-					1 => StringValues::DAMAGE_SLIGHTLY_DAMAGED,
-					2 => StringValues::DAMAGE_VERY_DAMAGED,
-					default => throw new BlockStateSerializeException("Invalid Anvil damage {$damage}"),
-				});
-		});
-		$this->map(Blocks::AZURE_BLUET(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_HOUSTONIA));
+		$this->map(Blocks::ANVIL(), fn(Anvil $block) : Writer => Writer::create(
+			match($damage = $block->getDamage()){
+				0 => Ids::ANVIL,
+				1 => Ids::CHIPPED_ANVIL,
+				2 => Ids::DAMAGED_ANVIL,
+				default => throw new BlockStateSerializeException("Invalid Anvil damage {$damage}"),
+			})
+			->writeCardinalHorizontalFacing($block->getFacing())
+		);
 		$this->map(Blocks::BAMBOO(), function(Bamboo $block) : Writer{
 			return Writer::create(Ids::BAMBOO)
 				->writeBool(StateNames::AGE_BIT, $block->isReady())
@@ -1013,10 +1115,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		});
 		$this->map(Blocks::BAMBOO_SAPLING(), function(BambooSapling $block) : Writer{
 			return Writer::create(Ids::BAMBOO_SAPLING)
-				->writeBool(StateNames::AGE_BIT, $block->isReady())
-
-				//TODO: bug in MCPE
-				->writeString(StateNames::SAPLING_TYPE, StringValues::SAPLING_TYPE_OAK);
+				->writeBool(StateNames::AGE_BIT, $block->isReady());
 		});
 		$this->map(Blocks::BANNER(), function(FloorBanner $block) : Writer{
 			return Writer::create(Ids::STANDING_BANNER)
@@ -1066,12 +1165,10 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeString(StateNames::BIG_DRIPLEAF_TILT, StringValues::BIG_DRIPLEAF_TILT_NONE)
 				->writeBool(StateNames::BIG_DRIPLEAF_HEAD, false);
 		});
-		$this->map(Blocks::BIRCH_SAPLING(), fn(Sapling $block) => Helper::encodeSapling($block, StringValues::SAPLING_TYPE_BIRCH));
 		$this->mapSlab(Blocks::BLACKSTONE_SLAB(), Ids::BLACKSTONE_SLAB, Ids::BLACKSTONE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::BLACKSTONE_STAIRS(), Ids::BLACKSTONE_STAIRS);
 		$this->map(Blocks::BLACKSTONE_WALL(), fn(Wall $block) => Helper::encodeWall($block, new Writer(Ids::BLACKSTONE_WALL)));
 		$this->map(Blocks::BLAST_FURNACE(), fn(Furnace $block) => Helper::encodeFurnace($block, Ids::BLAST_FURNACE, Ids::LIT_BLAST_FURNACE));
-		$this->map(Blocks::BLUE_ORCHID(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_ORCHID));
 		$this->map(Blocks::BLUE_TORCH(), fn(Torch $block) => Helper::encodeColoredTorch($block, false, Writer::create(Ids::COLORED_TORCH_BP)));
 		$this->map(Blocks::BONE_BLOCK(), function(BoneBlock $block) : Writer{
 			return Writer::create(Ids::BONE_BLOCK)
@@ -1084,7 +1181,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeBool(StateNames::BREWING_STAND_SLOT_B_BIT, $block->hasSlot(BrewingStandSlot::SOUTHWEST))
 				->writeBool(StateNames::BREWING_STAND_SLOT_C_BIT, $block->hasSlot(BrewingStandSlot::NORTHWEST));
 		});
-		$this->map(Blocks::BRICK_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab1($block, StringValues::STONE_SLAB_TYPE_BRICK));
+		$this->mapSlab(Blocks::BRICK_SLAB(), Ids::BRICK_SLAB, Ids::BRICK_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::BRICK_STAIRS(), Ids::BRICK_STAIRS);
 		$this->map(Blocks::BRICK_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_BRICK));
 		$this->map(Blocks::BROWN_MUSHROOM_BLOCK(), fn(BrownMushroomBlock $block) => Helper::encodeMushroomBlock($block, new Writer(Ids::BROWN_MUSHROOM_BLOCK)));
@@ -1129,10 +1226,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeLegacyHorizontalFacing($block->getFacing())
 				->writeInt(StateNames::BOOKS_STORED, $flags);
 		});
-		$this->map(Blocks::CHISELED_QUARTZ(), fn(SimplePillar $block) => Helper::encodeQuartz(StringValues::CHISEL_TYPE_CHISELED, $block->getAxis()));
-		$this->map(Blocks::CHISELED_RED_SANDSTONE(), fn() => Helper::encodeSandstone(Ids::RED_SANDSTONE, StringValues::SAND_STONE_TYPE_HEIROGLYPHS));
-		$this->map(Blocks::CHISELED_SANDSTONE(), fn() => Helper::encodeSandstone(Ids::SANDSTONE, StringValues::SAND_STONE_TYPE_HEIROGLYPHS));
-		$this->map(Blocks::CHISELED_STONE_BRICKS(), fn() => Helper::encodeStoneBricks(StringValues::STONE_BRICK_TYPE_CHISELED));
+		$this->map(Blocks::CHISELED_QUARTZ(), fn(SimplePillar $block) => Helper::encodeQuartz($block->getAxis(), Writer::create(Ids::CHISELED_QUARTZ_BLOCK)));
 		$this->map(Blocks::CHORUS_FLOWER(), function(ChorusFlower $block) : Writer{
 			return Writer::create(Ids::CHORUS_FLOWER)
 				->writeInt(StateNames::AGE, $block->getAge());
@@ -1140,7 +1234,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSlab(Blocks::COBBLED_DEEPSLATE_SLAB(), Ids::COBBLED_DEEPSLATE_SLAB, Ids::COBBLED_DEEPSLATE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::COBBLED_DEEPSLATE_STAIRS(), Ids::COBBLED_DEEPSLATE_STAIRS);
 		$this->map(Blocks::COBBLED_DEEPSLATE_WALL(), fn(Wall $block) => Helper::encodeWall($block, new Writer(Ids::COBBLED_DEEPSLATE_WALL)));
-		$this->map(Blocks::COBBLESTONE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab1($block, StringValues::STONE_SLAB_TYPE_COBBLESTONE));
+		$this->mapSlab(Blocks::COBBLESTONE_SLAB(), Ids::COBBLESTONE_SLAB, Ids::COBBLESTONE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::COBBLESTONE_STAIRS(), Ids::STONE_STAIRS);
 		$this->map(Blocks::COBBLESTONE_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_COBBLESTONE));
 		$this->map(Blocks::COPPER(), function(Copper $block) : Writer{
@@ -1223,30 +1317,9 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeLegacyHorizontalFacing(Facing::opposite($block->getFacing()));
 		});
 		$this->map(Blocks::COMPOUND_CREATOR(), fn(ChemistryTable $block) => Helper::encodeChemistryTable($block, StringValues::CHEMISTRY_TABLE_TYPE_COMPOUND_CREATOR, new Writer(Ids::CHEMISTRY_TABLE)));
-		$this->map(Blocks::CORAL_BLOCK(), function(CoralBlock $block) : Writer{
-			return Writer::create(Ids::CORAL_BLOCK)
-				->writeBool(StateNames::DEAD_BIT, $block->isDead())
-				->writeCoralType($block->getCoralType());
-		});
-		$this->map(Blocks::CORAL_FAN(), function(FloorCoralFan $block) : Writer{
-			return Writer::create($block->isDead() ? Ids::CORAL_FAN_DEAD : Ids::CORAL_FAN)
-				->writeCoralType($block->getCoralType())
-				->writeInt(StateNames::CORAL_FAN_DIRECTION, match($axis = $block->getAxis()){
-					Axis::X => 0,
-					Axis::Z => 1,
-					default => throw new BlockStateSerializeException("Invalid axis {$axis}"),
-				});
-		});
-		$this->map(Blocks::CORNFLOWER(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_CORNFLOWER));
-		$this->map(Blocks::CRACKED_STONE_BRICKS(), fn() => Helper::encodeStoneBricks(StringValues::STONE_BRICK_TYPE_CRACKED));
-		$this->map(Blocks::CUT_RED_SANDSTONE(), fn() => Helper::encodeSandstone(Ids::RED_SANDSTONE, StringValues::SAND_STONE_TYPE_CUT));
-		$this->map(Blocks::CUT_RED_SANDSTONE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab4($block, StringValues::STONE_SLAB_TYPE_4_CUT_RED_SANDSTONE));
-		$this->map(Blocks::CUT_SANDSTONE(), fn() => Helper::encodeSandstone(Ids::SANDSTONE, StringValues::SAND_STONE_TYPE_CUT));
-		$this->map(Blocks::CUT_SANDSTONE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab4($block, StringValues::STONE_SLAB_TYPE_4_CUT_SANDSTONE));
-		$this->map(Blocks::DARK_OAK_SAPLING(), fn(Sapling $block) => Helper::encodeSapling($block, StringValues::SAPLING_TYPE_DARK_OAK));
-		$this->map(Blocks::DARK_PRISMARINE(), fn() => Writer::create(Ids::PRISMARINE)
-				->writeString(StateNames::PRISMARINE_BLOCK_TYPE, StringValues::PRISMARINE_BLOCK_TYPE_DARK));
-		$this->map(Blocks::DARK_PRISMARINE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab2($block, StringValues::STONE_SLAB_TYPE_2_PRISMARINE_DARK));
+		$this->mapSlab(Blocks::CUT_RED_SANDSTONE_SLAB(), Ids::CUT_RED_SANDSTONE_SLAB, Ids::CUT_RED_SANDSTONE_DOUBLE_SLAB);
+		$this->mapSlab(Blocks::CUT_SANDSTONE_SLAB(), Ids::CUT_SANDSTONE_SLAB, Ids::CUT_SANDSTONE_DOUBLE_SLAB);
+		$this->mapSlab(Blocks::DARK_PRISMARINE_SLAB(), Ids::DARK_PRISMARINE_SLAB, Ids::DARK_PRISMARINE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::DARK_PRISMARINE_STAIRS(), Ids::DARK_PRISMARINE_STAIRS);
 		$this->map(Blocks::DAYLIGHT_SENSOR(), function(DaylightSensor $block) : Writer{
 			return Writer::create($block->isInverted() ? Ids::DAYLIGHT_DETECTOR_INVERTED : Ids::DAYLIGHT_DETECTOR)
@@ -1268,23 +1341,17 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeBool(StateNames::RAIL_DATA_BIT, $block->isActivated())
 				->writeInt(StateNames::RAIL_DIRECTION, $block->getShape());
 		});
-		$this->map(Blocks::DIORITE(), fn() => Helper::encodeStone(StringValues::STONE_TYPE_DIORITE));
-		$this->map(Blocks::DIORITE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab3($block, StringValues::STONE_SLAB_TYPE_3_DIORITE));
+		$this->mapSlab(Blocks::DIORITE_SLAB(), Ids::DIORITE_SLAB, Ids::DIORITE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::DIORITE_STAIRS(), Ids::DIORITE_STAIRS);
 		$this->map(Blocks::DIORITE_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_DIORITE));
 		$this->map(Blocks::DIRT(), function(Dirt $block) : Writer{
-			$dirtType = $block->getDirtType();
-			if($dirtType === DirtType::ROOTED){
-				return new Writer(Ids::DIRT_WITH_ROOTS);
-			}
-			return Writer::create(Ids::DIRT)
-				->writeString(StateNames::DIRT_TYPE, match($dirtType){
-					DirtType::COARSE => StringValues::DIRT_TYPE_COARSE,
-					DirtType::NORMAL => StringValues::DIRT_TYPE_NORMAL,
-					//ROOTED was already checked above
-				});
+			return Writer::create(match($block->getDirtType()){
+				DirtType::NORMAL => Ids::DIRT,
+				DirtType::COARSE => Ids::COARSE_DIRT,
+				DirtType::ROOTED => Ids::DIRT_WITH_ROOTS,
+			});
 		});
-		$this->map(Blocks::DOUBLE_TALLGRASS(), fn(DoubleTallGrass $block) => Helper::encodeDoublePlant($block, StringValues::DOUBLE_PLANT_TYPE_GRASS, Writer::create(Ids::DOUBLE_PLANT)));
+		$this->map(Blocks::DOUBLE_TALLGRASS(), fn(DoubleTallGrass $block) => Helper::encodeDoublePlant($block, Writer::create(Ids::TALL_GRASS)));
 		$this->map(Blocks::ELEMENT_CONSTRUCTOR(), fn(ChemistryTable $block) => Helper::encodeChemistryTable($block, StringValues::CHEMISTRY_TABLE_TYPE_ELEMENT_CONSTRUCTOR, new Writer(Ids::CHEMISTRY_TABLE)));
 		$this->map(Blocks::ENDER_CHEST(), function(EnderChest $block) : Writer{
 			return Writer::create(Ids::ENDER_CHEST)
@@ -1299,16 +1366,14 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 			return Writer::create(Ids::END_ROD)
 				->writeEndRodFacingDirection($block->getFacing());
 		});
-		$this->map(Blocks::END_STONE_BRICK_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab3($block, StringValues::STONE_SLAB_TYPE_3_END_STONE_BRICK));
+		$this->mapSlab(Blocks::END_STONE_BRICK_SLAB(), Ids::END_STONE_BRICK_SLAB, Ids::END_STONE_BRICK_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::END_STONE_BRICK_STAIRS(), Ids::END_BRICK_STAIRS);
 		$this->map(Blocks::END_STONE_BRICK_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_END_BRICK));
-		$this->map(Blocks::FAKE_WOODEN_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab1($block, StringValues::STONE_SLAB_TYPE_WOOD));
+		$this->mapSlab(Blocks::FAKE_WOODEN_SLAB(), Ids::PETRIFIED_OAK_SLAB, Ids::PETRIFIED_OAK_DOUBLE_SLAB);
 		$this->map(Blocks::FARMLAND(), function(Farmland $block) : Writer{
 			return Writer::create(Ids::FARMLAND)
 				->writeInt(StateNames::MOISTURIZED_AMOUNT, $block->getWetness());
 		});
-		$this->map(Blocks::FERN(), fn() => Writer::create(Ids::TALLGRASS)
-				->writeString(StateNames::TALL_GRASS_TYPE, StringValues::TALL_GRASS_TYPE_FERN));
 		$this->map(Blocks::FIRE(), function(Fire $block) : Writer{
 			return Writer::create(Ids::FIRE)
 				->writeInt(StateNames::AGE, $block->getAge());
@@ -1335,8 +1400,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeFacingFlags($block->getFaces());
 		});
 		$this->map(Blocks::GLOWING_ITEM_FRAME(), fn(ItemFrame $block) => Helper::encodeItemFrame($block, Ids::GLOW_FRAME));
-		$this->map(Blocks::GRANITE(), fn() => Helper::encodeStone(StringValues::STONE_TYPE_GRANITE));
-		$this->map(Blocks::GRANITE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab3($block, StringValues::STONE_SLAB_TYPE_3_GRANITE));
+		$this->mapSlab(Blocks::GRANITE_SLAB(), Ids::GRANITE_SLAB, Ids::GRANITE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::GRANITE_STAIRS(), Ids::GRANITE_STAIRS);
 		$this->map(Blocks::GRANITE_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_GRANITE));
 		$this->map(Blocks::GREEN_TORCH(), fn(Torch $block) => Helper::encodeColoredTorch($block, true, Writer::create(Ids::COLORED_TORCH_RG)));
@@ -1350,22 +1414,9 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeBool(StateNames::TOGGLE_BIT, $block->isPowered())
 				->writeFacingWithoutUp($block->getFacing());
 		});
-		$this->map(Blocks::INFESTED_CHISELED_STONE_BRICK(), fn() => Writer::create(Ids::MONSTER_EGG)
-				->writeString(StateNames::MONSTER_EGG_STONE_TYPE, StringValues::MONSTER_EGG_STONE_TYPE_CHISELED_STONE_BRICK));
-		$this->map(Blocks::INFESTED_COBBLESTONE(), fn() => Writer::create(Ids::MONSTER_EGG)
-				->writeString(StateNames::MONSTER_EGG_STONE_TYPE, StringValues::MONSTER_EGG_STONE_TYPE_COBBLESTONE));
-		$this->map(Blocks::INFESTED_CRACKED_STONE_BRICK(), fn() => Writer::create(Ids::MONSTER_EGG)
-				->writeString(StateNames::MONSTER_EGG_STONE_TYPE, StringValues::MONSTER_EGG_STONE_TYPE_CRACKED_STONE_BRICK));
-		$this->map(Blocks::INFESTED_MOSSY_STONE_BRICK(), fn() => Writer::create(Ids::MONSTER_EGG)
-				->writeString(StateNames::MONSTER_EGG_STONE_TYPE, StringValues::MONSTER_EGG_STONE_TYPE_MOSSY_STONE_BRICK));
-		$this->map(Blocks::INFESTED_STONE(), fn() => Writer::create(Ids::MONSTER_EGG)
-				->writeString(StateNames::MONSTER_EGG_STONE_TYPE, StringValues::MONSTER_EGG_STONE_TYPE_STONE));
-		$this->map(Blocks::INFESTED_STONE_BRICK(), fn() => Writer::create(Ids::MONSTER_EGG)
-				->writeString(StateNames::MONSTER_EGG_STONE_TYPE, StringValues::MONSTER_EGG_STONE_TYPE_STONE_BRICK));
 		$this->map(Blocks::IRON_DOOR(), fn(Door $block) => Helper::encodeDoor($block, new Writer(Ids::IRON_DOOR)));
 		$this->map(Blocks::IRON_TRAPDOOR(), fn(Trapdoor $block) => Helper::encodeTrapdoor($block, new Writer(Ids::IRON_TRAPDOOR)));
 		$this->map(Blocks::ITEM_FRAME(), fn(ItemFrame $block) => Helper::encodeItemFrame($block, Ids::FRAME));
-		$this->map(Blocks::JUNGLE_SAPLING(), fn(Sapling $block) => Helper::encodeSapling($block, StringValues::SAPLING_TYPE_JUNGLE));
 		$this->map(Blocks::LAB_TABLE(), fn(ChemistryTable $block) => Helper::encodeChemistryTable($block, StringValues::CHEMISTRY_TABLE_TYPE_LAB_TABLE, new Writer(Ids::CHEMISTRY_TABLE)));
 		$this->map(Blocks::LADDER(), function(Ladder $block) : Writer{
 			return Writer::create(Ids::LADDER)
@@ -1375,7 +1426,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 			return Writer::create(Ids::LANTERN)
 				->writeBool(StateNames::HANGING, $block->isHanging());
 		});
-		$this->map(Blocks::LARGE_FERN(), fn(DoubleTallGrass $block) => Helper::encodeDoublePlant($block, StringValues::DOUBLE_PLANT_TYPE_FERN, Writer::create(Ids::DOUBLE_PLANT)));
+		$this->map(Blocks::LARGE_FERN(), fn(DoubleTallGrass $block) => Helper::encodeDoublePlant($block, Writer::create(Ids::LARGE_FERN)));
 		$this->map(Blocks::LAVA(), fn(Lava $block) => Helper::encodeLiquid($block, Ids::LAVA, Ids::FLOWING_LAVA));
 		$this->map(Blocks::LECTERN(), function(Lectern $block) : Writer{
 			return Writer::create(Ids::LECTERN)
@@ -1397,15 +1448,31 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				});
 		});
 		$this->map(Blocks::LIGHT(), function(Light $block) : Writer{
-			return Writer::create(Ids::LIGHT_BLOCK)
-				->writeInt(StateNames::BLOCK_LIGHT_LEVEL, $block->getLightLevel());
+			return Writer::create(match($block->getLightLevel()){
+				0 => Ids::LIGHT_BLOCK_0,
+				1 => Ids::LIGHT_BLOCK_1,
+				2 => Ids::LIGHT_BLOCK_2,
+				3 => Ids::LIGHT_BLOCK_3,
+				4 => Ids::LIGHT_BLOCK_4,
+				5 => Ids::LIGHT_BLOCK_5,
+				6 => Ids::LIGHT_BLOCK_6,
+				7 => Ids::LIGHT_BLOCK_7,
+				8 => Ids::LIGHT_BLOCK_8,
+				9 => Ids::LIGHT_BLOCK_9,
+				10 => Ids::LIGHT_BLOCK_10,
+				11 => Ids::LIGHT_BLOCK_11,
+				12 => Ids::LIGHT_BLOCK_12,
+				13 => Ids::LIGHT_BLOCK_13,
+				14 => Ids::LIGHT_BLOCK_14,
+				15 => Ids::LIGHT_BLOCK_15,
+				default => throw new BlockStateSerializeException("Invalid light level " . $block->getLightLevel()),
+			});
 		});
 		$this->map(Blocks::LIGHTNING_ROD(), function(LightningRod $block) : Writer{
 			return Writer::create(Ids::LIGHTNING_ROD)
 				->writeFacingDirection($block->getFacing());
 		});
-		$this->map(Blocks::LILAC(), fn(DoublePlant $block) => Helper::encodeDoublePlant($block, StringValues::DOUBLE_PLANT_TYPE_SYRINGA, Writer::create(Ids::DOUBLE_PLANT)));
-		$this->map(Blocks::LILY_OF_THE_VALLEY(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_LILY_OF_THE_VALLEY));
+		$this->map(Blocks::LILAC(), fn(DoublePlant $block) => Helper::encodeDoublePlant($block, Writer::create(Ids::LILAC)));
 		$this->map(Blocks::LIT_PUMPKIN(), function(LitPumpkin $block) : Writer{
 			return Writer::create(Ids::LIT_PUMPKIN)
 				->writeCardinalHorizontalFacing($block->getFacing());
@@ -1420,11 +1487,10 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 			return Writer::create(Ids::SKULL)
 				->writeFacingWithoutDown($block->getFacing());
 		});
-		$this->map(Blocks::MOSSY_COBBLESTONE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab2($block, StringValues::STONE_SLAB_TYPE_2_MOSSY_COBBLESTONE));
+		$this->mapSlab(Blocks::MOSSY_COBBLESTONE_SLAB(), Ids::MOSSY_COBBLESTONE_SLAB, Ids::MOSSY_COBBLESTONE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::MOSSY_COBBLESTONE_STAIRS(), Ids::MOSSY_COBBLESTONE_STAIRS);
 		$this->map(Blocks::MOSSY_COBBLESTONE_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_MOSSY_COBBLESTONE));
-		$this->map(Blocks::MOSSY_STONE_BRICKS(), fn() => Helper::encodeStoneBricks(StringValues::STONE_BRICK_TYPE_MOSSY));
-		$this->map(Blocks::MOSSY_STONE_BRICK_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab4($block, StringValues::STONE_SLAB_TYPE_4_MOSSY_STONE_BRICK));
+		$this->mapSlab(Blocks::MOSSY_STONE_BRICK_SLAB(), Ids::MOSSY_STONE_BRICK_SLAB, Ids::MOSSY_STONE_BRICK_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::MOSSY_STONE_BRICK_STAIRS(), Ids::MOSSY_STONE_BRICK_STAIRS);
 		$this->map(Blocks::MOSSY_STONE_BRICK_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_MOSSY_STONE_BRICK));
 		$this->mapSlab(Blocks::MUD_BRICK_SLAB(), Ids::MUD_BRICK_SLAB, Ids::MUD_BRICK_DOUBLE_SLAB);
@@ -1434,7 +1500,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writePillarAxis($block->getAxis()));
 		$this->map(Blocks::MUSHROOM_STEM(), fn() => Writer::create(Ids::BROWN_MUSHROOM_BLOCK)
 				->writeInt(StateNames::HUGE_MUSHROOM_BITS, BlockLegacyMetadata::MUSHROOM_BLOCK_STEM));
-		$this->map(Blocks::NETHER_BRICK_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab1($block, StringValues::STONE_SLAB_TYPE_NETHER_BRICK));
+		$this->mapSlab(Blocks::NETHER_BRICK_SLAB(), Ids::NETHER_BRICK_SLAB, Ids::NETHER_BRICK_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::NETHER_BRICK_STAIRS(), Ids::NETHER_BRICK_STAIRS);
 		$this->map(Blocks::NETHER_BRICK_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_NETHER_BRICK));
 		$this->map(Blocks::NETHER_PORTAL(), function(NetherPortal $block) : Writer{
@@ -1449,16 +1515,12 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 			return Writer::create(Ids::NETHER_WART)
 				->writeInt(StateNames::AGE, $block->getAge());
 		});
-		$this->map(Blocks::OAK_SAPLING(), fn(Sapling $block) => Helper::encodeSapling($block, StringValues::SAPLING_TYPE_OAK));
-		$this->map(Blocks::ORANGE_TULIP(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_TULIP_ORANGE));
-		$this->map(Blocks::OXEYE_DAISY(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_OXEYE));
-		$this->map(Blocks::PEONY(), fn(DoublePlant $block) => Helper::encodeDoublePlant($block, StringValues::DOUBLE_PLANT_TYPE_PAEONIA, Writer::create(Ids::DOUBLE_PLANT)));
+		$this->map(Blocks::PEONY(), fn(DoublePlant $block) => Helper::encodeDoublePlant($block, Writer::create(Ids::PEONY)));
 		$this->map(Blocks::PINK_PETALS(), function(PinkPetals $block) : Writer{
 			return Writer::create(Ids::PINK_PETALS)
 				->writeCardinalHorizontalFacing($block->getFacing())
 				->writeInt(StateNames::GROWTH, $block->getCount() - 1);
 		});
-		$this->map(Blocks::PINK_TULIP(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_TULIP_PINK));
 		$this->map(Blocks::PITCHER_PLANT(), function(DoublePlant $block) : Writer{
 			return Writer::create(Ids::PITCHER_PLANT)
 				->writeBool(StateNames::UPPER_BLOCK_BIT, $block->isTop());
@@ -1473,8 +1535,7 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeInt(StateNames::GROWTH, $block->getAge() + 1 + PitcherCrop::MAX_AGE)
 				->writeBool(StateNames::UPPER_BLOCK_BIT, $block->isTop());
 		});
-		$this->map(Blocks::POLISHED_ANDESITE(), fn() => Helper::encodeStone(StringValues::STONE_TYPE_ANDESITE_SMOOTH));
-		$this->map(Blocks::POLISHED_ANDESITE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab3($block, StringValues::STONE_SLAB_TYPE_3_POLISHED_ANDESITE));
+		$this->mapSlab(Blocks::POLISHED_ANDESITE_SLAB(), Ids::POLISHED_ANDESITE_SLAB, Ids::POLISHED_ANDESITE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::POLISHED_ANDESITE_STAIRS(), Ids::POLISHED_ANDESITE_STAIRS);
 		$this->map(Blocks::POLISHED_BASALT(), function(SimplePillar $block) : Writer{
 			return Writer::create(Ids::POLISHED_BASALT)
@@ -1491,26 +1552,19 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 		$this->mapSlab(Blocks::POLISHED_DEEPSLATE_SLAB(), Ids::POLISHED_DEEPSLATE_SLAB, Ids::POLISHED_DEEPSLATE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::POLISHED_DEEPSLATE_STAIRS(), Ids::POLISHED_DEEPSLATE_STAIRS);
 		$this->map(Blocks::POLISHED_DEEPSLATE_WALL(), fn(Wall $block) => Helper::encodeWall($block, new Writer(Ids::POLISHED_DEEPSLATE_WALL)));
-		$this->map(Blocks::POLISHED_DIORITE(), fn() => Helper::encodeStone(StringValues::STONE_TYPE_DIORITE_SMOOTH));
-		$this->map(Blocks::POLISHED_DIORITE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab3($block, StringValues::STONE_SLAB_TYPE_3_POLISHED_DIORITE));
+		$this->mapSlab(Blocks::POLISHED_DIORITE_SLAB(), Ids::POLISHED_DIORITE_SLAB, Ids::POLISHED_DIORITE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::POLISHED_DIORITE_STAIRS(), Ids::POLISHED_DIORITE_STAIRS);
-		$this->map(Blocks::POLISHED_GRANITE(), fn() => Helper::encodeStone(StringValues::STONE_TYPE_GRANITE_SMOOTH));
-		$this->map(Blocks::POLISHED_GRANITE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab3($block, StringValues::STONE_SLAB_TYPE_3_POLISHED_GRANITE));
+		$this->mapSlab(Blocks::POLISHED_GRANITE_SLAB(), Ids::POLISHED_GRANITE_SLAB, Ids::POLISHED_GRANITE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::POLISHED_GRANITE_STAIRS(), Ids::POLISHED_GRANITE_STAIRS);
-		$this->map(Blocks::POPPY(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_POPPY));
 		$this->map(Blocks::POTATOES(), fn(Potato $block) => Helper::encodeCrops($block, new Writer(Ids::POTATOES)));
 		$this->map(Blocks::POWERED_RAIL(), function(PoweredRail $block) : Writer{
 			return Writer::create(Ids::GOLDEN_RAIL)
 				->writeBool(StateNames::RAIL_DATA_BIT, $block->isPowered())
 				->writeInt(StateNames::RAIL_DIRECTION, $block->getShape());
 		});
-		$this->map(Blocks::PRISMARINE(), fn() => Writer::create(Ids::PRISMARINE)
-				->writeString(StateNames::PRISMARINE_BLOCK_TYPE, StringValues::PRISMARINE_BLOCK_TYPE_DEFAULT));
-		$this->map(Blocks::PRISMARINE_BRICKS(), fn() => Writer::create(Ids::PRISMARINE)
-				->writeString(StateNames::PRISMARINE_BLOCK_TYPE, StringValues::PRISMARINE_BLOCK_TYPE_BRICKS));
-		$this->map(Blocks::PRISMARINE_BRICKS_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab2($block, StringValues::STONE_SLAB_TYPE_2_PRISMARINE_BRICK));
+		$this->mapSlab(Blocks::PRISMARINE_BRICKS_SLAB(), Ids::PRISMARINE_BRICK_SLAB, Ids::PRISMARINE_BRICK_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::PRISMARINE_BRICKS_STAIRS(), Ids::PRISMARINE_BRICKS_STAIRS);
-		$this->map(Blocks::PRISMARINE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab2($block, StringValues::STONE_SLAB_TYPE_2_PRISMARINE_ROUGH));
+		$this->mapSlab(Blocks::PRISMARINE_SLAB(), Ids::PRISMARINE_SLAB, Ids::PRISMARINE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::PRISMARINE_STAIRS(), Ids::PRISMARINE_STAIRS);
 		$this->map(Blocks::PRISMARINE_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_PRISMARINE));
 		$this->map(Blocks::PUMPKIN(), function() : Writer{
@@ -1529,11 +1583,11 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeString(StateNames::CHISEL_TYPE, StringValues::CHISEL_TYPE_LINES)
 				->writePillarAxis($block->getAxis());
 		});
-		$this->map(Blocks::PURPUR_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab2($block, StringValues::STONE_SLAB_TYPE_2_PURPUR));
+		$this->mapSlab(Blocks::PURPUR_SLAB(), Ids::PURPUR_SLAB, Ids::PURPUR_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::PURPUR_STAIRS(), Ids::PURPUR_STAIRS);
-		$this->map(Blocks::QUARTZ(), fn() => Helper::encodeQuartz(StringValues::CHISEL_TYPE_DEFAULT, Axis::Y));
-		$this->map(Blocks::QUARTZ_PILLAR(), fn(SimplePillar $block) => Helper::encodeQuartz(StringValues::CHISEL_TYPE_LINES, $block->getAxis()));
-		$this->map(Blocks::QUARTZ_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab1($block, StringValues::STONE_SLAB_TYPE_QUARTZ));
+		$this->map(Blocks::QUARTZ(), fn() => Helper::encodeQuartz(Axis::Y, Writer::create(Ids::QUARTZ_BLOCK)));
+		$this->map(Blocks::QUARTZ_PILLAR(), fn(SimplePillar $block) => Helper::encodeQuartz($block->getAxis(), Writer::create(Ids::QUARTZ_PILLAR)));
+		$this->mapSlab(Blocks::QUARTZ_SLAB(), Ids::QUARTZ_SLAB, Ids::QUARTZ_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::QUARTZ_STAIRS(), Ids::QUARTZ_STAIRS);
 		$this->map(Blocks::RAIL(), function(Rail $block) : Writer{
 			return Writer::create(Ids::RAIL)
@@ -1561,22 +1615,15 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeInt(StateNames::REDSTONE_SIGNAL, $block->getOutputSignalStrength());
 		});
 		$this->map(Blocks::RED_MUSHROOM_BLOCK(), fn(RedMushroomBlock $block) => Helper::encodeMushroomBlock($block, new Writer(Ids::RED_MUSHROOM_BLOCK)));
-		$this->map(Blocks::RED_NETHER_BRICK_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab2($block, StringValues::STONE_SLAB_TYPE_2_RED_NETHER_BRICK));
+		$this->mapSlab(Blocks::RED_NETHER_BRICK_SLAB(), Ids::RED_NETHER_BRICK_SLAB, Ids::RED_NETHER_BRICK_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::RED_NETHER_BRICK_STAIRS(), Ids::RED_NETHER_BRICK_STAIRS);
 		$this->map(Blocks::RED_NETHER_BRICK_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_RED_NETHER_BRICK));
-		$this->map(Blocks::RED_SAND(), fn() => Writer::create(Ids::SAND)
-				->writeString(StateNames::SAND_TYPE, StringValues::SAND_TYPE_RED));
-		$this->map(Blocks::RED_SANDSTONE(), fn() => Helper::encodeSandstone(Ids::RED_SANDSTONE, StringValues::SAND_STONE_TYPE_DEFAULT));
-		$this->map(Blocks::RED_SANDSTONE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab2($block, StringValues::STONE_SLAB_TYPE_2_RED_SANDSTONE));
+		$this->mapSlab(Blocks::RED_SANDSTONE_SLAB(), Ids::RED_SANDSTONE_SLAB, Ids::RED_SANDSTONE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::RED_SANDSTONE_STAIRS(), Ids::RED_SANDSTONE_STAIRS);
 		$this->map(Blocks::RED_SANDSTONE_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_RED_SANDSTONE));
 		$this->map(Blocks::RED_TORCH(), fn(Torch $block) => Helper::encodeColoredTorch($block, false, Writer::create(Ids::COLORED_TORCH_RG)));
-		$this->map(Blocks::RED_TULIP(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_TULIP_RED));
-		$this->map(Blocks::ROSE_BUSH(), fn(DoublePlant $block) => Helper::encodeDoublePlant($block, StringValues::DOUBLE_PLANT_TYPE_ROSE, Writer::create(Ids::DOUBLE_PLANT)));
-		$this->map(Blocks::SAND(), fn() => Writer::create(Ids::SAND)
-				->writeString(StateNames::SAND_TYPE, StringValues::SAND_TYPE_NORMAL));
-		$this->map(Blocks::SANDSTONE(), fn() => Helper::encodeSandstone(Ids::SANDSTONE, StringValues::SAND_STONE_TYPE_DEFAULT));
-		$this->map(Blocks::SANDSTONE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab1($block, StringValues::STONE_SLAB_TYPE_SANDSTONE));
+		$this->map(Blocks::ROSE_BUSH(), fn(DoublePlant $block) => Helper::encodeDoublePlant($block, Writer::create(Ids::ROSE_BUSH)));
+		$this->mapSlab(Blocks::SANDSTONE_SLAB(), Ids::SANDSTONE_SLAB, Ids::SANDSTONE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::SANDSTONE_STAIRS(), Ids::SANDSTONE_STAIRS);
 		$this->map(Blocks::SANDSTONE_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_SANDSTONE));
 		$this->map(Blocks::SEA_PICKLE(), function(SeaPickle $block) : Writer{
@@ -1590,16 +1637,14 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeBool(StateNames::UPPER_BLOCK_BIT, $block->isTop());
 		});
 		$this->map(Blocks::SMOKER(), fn(Furnace $block) => Helper::encodeFurnace($block, Ids::SMOKER, Ids::LIT_SMOKER));
-		$this->map(Blocks::SMOOTH_QUARTZ(), fn() => Helper::encodeQuartz(StringValues::CHISEL_TYPE_SMOOTH, Axis::Y));
-		$this->map(Blocks::SMOOTH_QUARTZ_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab4($block, StringValues::STONE_SLAB_TYPE_4_SMOOTH_QUARTZ));
+		$this->map(Blocks::SMOOTH_QUARTZ(), fn() => Helper::encodeQuartz(Axis::Y, Writer::create(Ids::SMOOTH_QUARTZ)));
+		$this->mapSlab(Blocks::SMOOTH_QUARTZ_SLAB(), Ids::SMOOTH_QUARTZ_SLAB, Ids::SMOOTH_QUARTZ_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::SMOOTH_QUARTZ_STAIRS(), Ids::SMOOTH_QUARTZ_STAIRS);
-		$this->map(Blocks::SMOOTH_RED_SANDSTONE(), fn() => Helper::encodeSandstone(Ids::RED_SANDSTONE, StringValues::SAND_STONE_TYPE_SMOOTH));
-		$this->map(Blocks::SMOOTH_RED_SANDSTONE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab3($block, StringValues::STONE_SLAB_TYPE_3_SMOOTH_RED_SANDSTONE));
+		$this->mapSlab(Blocks::SMOOTH_RED_SANDSTONE_SLAB(), Ids::SMOOTH_RED_SANDSTONE_SLAB, Ids::SMOOTH_RED_SANDSTONE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::SMOOTH_RED_SANDSTONE_STAIRS(), Ids::SMOOTH_RED_SANDSTONE_STAIRS);
-		$this->map(Blocks::SMOOTH_SANDSTONE(), fn() => Helper::encodeSandstone(Ids::SANDSTONE, StringValues::SAND_STONE_TYPE_SMOOTH));
-		$this->map(Blocks::SMOOTH_SANDSTONE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab2($block, StringValues::STONE_SLAB_TYPE_2_SMOOTH_SANDSTONE));
+		$this->mapSlab(Blocks::SMOOTH_SANDSTONE_SLAB(), Ids::SMOOTH_SANDSTONE_SLAB, Ids::SMOOTH_SANDSTONE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::SMOOTH_SANDSTONE_STAIRS(), Ids::SMOOTH_SANDSTONE_STAIRS);
-		$this->map(Blocks::SMOOTH_STONE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab1($block, StringValues::STONE_SLAB_TYPE_SMOOTH_STONE));
+		$this->mapSlab(Blocks::SMOOTH_STONE_SLAB(), Ids::SMOOTH_STONE_SLAB, Ids::SMOOTH_STONE_DOUBLE_SLAB);
 		$this->map(Blocks::SNOW_LAYER(), function(SnowLayer $block) : Writer{
 			return Writer::create(Ids::SNOW_LAYER)
 				->writeBool(StateNames::COVERED_BIT, false)
@@ -1621,37 +1666,24 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 			return Writer::create(Ids::SPONGE)
 				->writeString(StateNames::SPONGE_TYPE, $block->isWet() ? StringValues::SPONGE_TYPE_WET : StringValues::SPONGE_TYPE_DRY);
 		});
-		$this->map(Blocks::SPRUCE_SAPLING(), fn(Sapling $block) => Helper::encodeSapling($block, StringValues::SAPLING_TYPE_SPRUCE));
-		$this->map(Blocks::STAINED_HARDENED_GLASS(), function(StainedHardenedGlass $block) : Writer{
-			return Writer::create(Ids::HARD_STAINED_GLASS)
-				->writeColor($block->getColor());
-		});
-		$this->map(Blocks::STAINED_HARDENED_GLASS_PANE(), function(StainedHardenedGlassPane $block) : Writer{
-			return Writer::create(Ids::HARD_STAINED_GLASS_PANE)
-				->writeColor($block->getColor());
-		});
-		$this->map(Blocks::STONE(), fn() => Helper::encodeStone(StringValues::STONE_TYPE_STONE));
 		$this->map(Blocks::STONECUTTER(), fn(Stonecutter $block) => Writer::create(Ids::STONECUTTER_BLOCK)
 			->writeCardinalHorizontalFacing($block->getFacing()));
-		$this->map(Blocks::STONE_BRICKS(), fn() => Helper::encodeStoneBricks(StringValues::STONE_BRICK_TYPE_DEFAULT));
-		$this->map(Blocks::STONE_BRICK_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab1($block, StringValues::STONE_SLAB_TYPE_STONE_BRICK));
+		$this->mapSlab(Blocks::STONE_BRICK_SLAB(), Ids::STONE_BRICK_SLAB, Ids::STONE_BRICK_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::STONE_BRICK_STAIRS(), Ids::STONE_BRICK_STAIRS);
 		$this->map(Blocks::STONE_BRICK_WALL(), fn(Wall $block) => Helper::encodeLegacyWall($block, StringValues::WALL_BLOCK_TYPE_STONE_BRICK));
 		$this->map(Blocks::STONE_BUTTON(), fn(StoneButton $block) => Helper::encodeButton($block, new Writer(Ids::STONE_BUTTON)));
 		$this->map(Blocks::STONE_PRESSURE_PLATE(), fn(StonePressurePlate $block) => Helper::encodeSimplePressurePlate($block, new Writer(Ids::STONE_PRESSURE_PLATE)));
-		$this->map(Blocks::STONE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab4($block, StringValues::STONE_SLAB_TYPE_4_STONE));
+		$this->mapSlab(Blocks::STONE_SLAB(), Ids::NORMAL_STONE_SLAB, Ids::NORMAL_STONE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::STONE_STAIRS(), Ids::NORMAL_STONE_STAIRS);
 		$this->map(Blocks::SUGARCANE(), function(Sugarcane $block) : Writer{
 			return Writer::create(Ids::REEDS)
 				->writeInt(StateNames::AGE, $block->getAge());
 		});
-		$this->map(Blocks::SUNFLOWER(), fn(DoublePlant $block) => Helper::encodeDoublePlant($block, StringValues::DOUBLE_PLANT_TYPE_SUNFLOWER, Writer::create(Ids::DOUBLE_PLANT)));
+		$this->map(Blocks::SUNFLOWER(), fn(DoublePlant $block) => Helper::encodeDoublePlant($block, Writer::create(Ids::SUNFLOWER)));
 		$this->map(Blocks::SWEET_BERRY_BUSH(), function(SweetBerryBush $block) : Writer{
 			return Writer::create(Ids::SWEET_BERRY_BUSH)
 				->writeInt(StateNames::GROWTH, $block->getAge());
 		});
-		$this->map(Blocks::TALL_GRASS(), fn() => Writer::create(Ids::TALLGRASS)
-				->writeString(StateNames::TALL_GRASS_TYPE, StringValues::TALL_GRASS_TYPE_TALL));
 		$this->map(Blocks::TNT(), function(TNT $block) : Writer{
 			return Writer::create(Ids::TNT)
 				->writeBool(StateNames::ALLOW_UNDERWATER_BIT, $block->worksUnderwater())
@@ -1698,17 +1730,6 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 			return Writer::create(Ids::WALL_BANNER)
 				->writeHorizontalFacing($block->getFacing());
 		});
-		$this->map(Blocks::WALL_CORAL_FAN(), function(WallCoralFan $block) : Writer{
-			$coralType = $block->getCoralType();
-			return Writer::create(match($coralType){
-				CoralType::TUBE, CoralType::BRAIN => Ids::CORAL_FAN_HANG,
-				CoralType::BUBBLE, CoralType::FIRE => Ids::CORAL_FAN_HANG2,
-				CoralType::HORN => Ids::CORAL_FAN_HANG3,
-			})
-				->writeBool(StateNames::CORAL_HANG_TYPE_BIT, $coralType === CoralType::BRAIN || $coralType === CoralType::FIRE)
-				->writeBool(StateNames::DEAD_BIT, $block->isDead())
-				->writeCoralFacing($block->getFacing());
-		});
 		$this->map(Blocks::WATER(), fn(Water $block) => Helper::encodeLiquid($block, Ids::WATER, Ids::FLOWING_WATER));
 		$this->map(Blocks::WEEPING_VINES(), function(NetherVines $block) : Writer{
 			return Writer::create(Ids::WEEPING_VINES)
@@ -1723,6 +1744,5 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeInt(StateNames::REDSTONE_SIGNAL, $block->getOutputSignalStrength());
 		});
 		$this->map(Blocks::WHEAT(), fn(Wheat $block) => Helper::encodeCrops($block, new Writer(Ids::WHEAT)));
-		$this->map(Blocks::WHITE_TULIP(), fn() => Helper::encodeRedFlower(StringValues::FLOWER_TYPE_TULIP_WHITE));
 	}
 }

src/data/bedrock/block/convert/BlockStateDeserializerHelper.php

@@ -32,6 +32,7 @@ use pocketmine\block\CopperStairs;
 use pocketmine\block\Crops;
 use pocketmine\block\DaylightSensor;
 use pocketmine\block\Door;
+use pocketmine\block\DoublePlant;
 use pocketmine\block\FenceGate;
 use pocketmine\block\FloorCoralFan;
 use pocketmine\block\FloorSign;
@@ -41,12 +42,14 @@ use pocketmine\block\Liquid;
 use pocketmine\block\RedMushroomBlock;
 use pocketmine\block\RedstoneComparator;
 use pocketmine\block\RedstoneRepeater;
+use pocketmine\block\Sapling;
 use pocketmine\block\SimplePressurePlate;
 use pocketmine\block\Slab;
 use pocketmine\block\Stair;
 use pocketmine\block\Stem;
 use pocketmine\block\Trapdoor;
 use pocketmine\block\utils\CopperOxidation;
+use pocketmine\block\utils\SlabType;
 use pocketmine\block\VanillaBlocks;
 use pocketmine\block\Wall;
 use pocketmine\block\WallCoralFan;
@@ -138,6 +141,12 @@ final class BlockStateDeserializerHelper{
 			->setOpen($in->readBool(BlockStateNames::OPEN_BIT));
 	}
 
+	/** @throws BlockStateDeserializeException */
+	public static function decodeDoublePlant(DoublePlant $block, BlockStateReader $in) : DoublePlant{
+		return $block
+			->setTop($in->readBool(BlockStateNames::UPPER_BLOCK_BIT));
+	}
+
 	/** @throws BlockStateDeserializeException */
 	public static function decodeFenceGate(FenceGate $block, BlockStateReader $in) : FenceGate{
 		return $block
@@ -149,7 +158,6 @@ final class BlockStateDeserializerHelper{
 	/** @throws BlockStateDeserializeException */
 	public static function decodeFloorCoralFan(FloorCoralFan $block, BlockStateReader $in) : FloorCoralFan{
 		return $block
-			->setCoralType($in->readCoralType())
 			->setAxis(match($in->readBoundedInt(BlockStateNames::CORAL_FAN_DIRECTION, 0, 1)){
 				0 => Axis::X,
 				1 => Axis::Z,
@@ -220,6 +228,12 @@ final class BlockStateDeserializerHelper{
 			->setDelay($in->readBoundedInt(BlockStateNames::REPEATER_DELAY, 0, 3) + 1);
 	}
 
+	/** @throws BlockStateDeserializeException */
+	public static function decodeSapling(Sapling $block, BlockStateReader $in) : Sapling{
+		return $block
+			->setReady($in->readBool(BlockStateNames::AGE_BIT));
+	}
+
 	/** @throws BlockStateDeserializeException */
 	public static function decodeSimplePressurePlate(SimplePressurePlate $block, BlockStateReader $in) : SimplePressurePlate{
 		//TODO: not sure what the deal is here ... seems like a mojang bug / artifact of bad implementation?
@@ -227,6 +241,17 @@ final class BlockStateDeserializerHelper{
 		return $block->setPressed($in->readBoundedInt(BlockStateNames::REDSTONE_SIGNAL, 0, 15) !== 0);
 	}
 
+	/** @throws BlockStateDeserializeException */
+	public static function decodeSingleSlab(Slab $block, BlockStateReader $in) : Slab{
+		return $block->setSlabType($in->readSlabPosition());
+	}
+
+	/** @throws BlockStateDeserializeException */
+	public static function decodeDoubleSlab(Slab $block, BlockStateReader $in) : Slab{
+		$in->ignored(StateNames::MC_VERTICAL_HALF);
+		return $block->setSlabType(SlabType::DOUBLE);
+	}
+
 	/** @throws BlockStateDeserializeException */
 	public static function decodeStairs(Stair $block, BlockStateReader $in) : Stair{
 		return $block
@@ -301,79 +326,4 @@ final class BlockStateDeserializerHelper{
 			default => throw $in->badValueException(BlockStateNames::WALL_BLOCK_TYPE, $type),
 		}, $in);
 	}
-
-	/** @throws BlockStateDeserializeException */
-	public static function mapStoneSlab1Type(BlockStateReader $in) : Slab{
-		//* stone_slab_type (StringTag) = brick, cobblestone, nether_brick, quartz, sandstone, smooth_stone, stone_brick, wood
-		return match($type = $in->readString(BlockStateNames::STONE_SLAB_TYPE)){
-			StringValues::STONE_SLAB_TYPE_BRICK => VanillaBlocks::BRICK_SLAB(),
-			StringValues::STONE_SLAB_TYPE_COBBLESTONE => VanillaBlocks::COBBLESTONE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_NETHER_BRICK => VanillaBlocks::NETHER_BRICK_SLAB(),
-			StringValues::STONE_SLAB_TYPE_QUARTZ => VanillaBlocks::QUARTZ_SLAB(),
-			StringValues::STONE_SLAB_TYPE_SANDSTONE => VanillaBlocks::SANDSTONE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_SMOOTH_STONE => VanillaBlocks::SMOOTH_STONE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_STONE_BRICK => VanillaBlocks::STONE_BRICK_SLAB(),
-			StringValues::STONE_SLAB_TYPE_WOOD => VanillaBlocks::FAKE_WOODEN_SLAB(),
-			default => throw $in->badValueException(BlockStateNames::STONE_SLAB_TYPE, $type),
-		};
-	}
-
-	/** @throws BlockStateDeserializeException */
-	public static function mapStoneSlab2Type(BlockStateReader $in) : Slab{
-		// * stone_slab_type_2 (StringTag) = mossy_cobblestone, prismarine_brick, prismarine_dark, prismarine_rough, purpur, red_nether_brick, red_sandstone, smooth_sandstone
-		return match($type = $in->readString(BlockStateNames::STONE_SLAB_TYPE_2)){
-			StringValues::STONE_SLAB_TYPE_2_MOSSY_COBBLESTONE => VanillaBlocks::MOSSY_COBBLESTONE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_2_PRISMARINE_BRICK => VanillaBlocks::PRISMARINE_BRICKS_SLAB(),
-			StringValues::STONE_SLAB_TYPE_2_PRISMARINE_DARK => VanillaBlocks::DARK_PRISMARINE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_2_PRISMARINE_ROUGH => VanillaBlocks::PRISMARINE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_2_PURPUR => VanillaBlocks::PURPUR_SLAB(),
-			StringValues::STONE_SLAB_TYPE_2_RED_NETHER_BRICK => VanillaBlocks::RED_NETHER_BRICK_SLAB(),
-			StringValues::STONE_SLAB_TYPE_2_RED_SANDSTONE => VanillaBlocks::RED_SANDSTONE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_2_SMOOTH_SANDSTONE => VanillaBlocks::SMOOTH_SANDSTONE_SLAB(),
-			default => throw $in->badValueException(BlockStateNames::STONE_SLAB_TYPE_2, $type),
-		};
-	}
-
-	/** @throws BlockStateDeserializeException */
-	public static function mapStoneSlab3Type(BlockStateReader $in) : Slab{
-		// * stone_slab_type_3 (StringTag) = andesite, diorite, end_stone_brick, granite, polished_andesite, polished_diorite, polished_granite, smooth_red_sandstone
-		return match($type = $in->readString(BlockStateNames::STONE_SLAB_TYPE_3)){
-			StringValues::STONE_SLAB_TYPE_3_ANDESITE => VanillaBlocks::ANDESITE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_3_DIORITE => VanillaBlocks::DIORITE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_3_END_STONE_BRICK => VanillaBlocks::END_STONE_BRICK_SLAB(),
-			StringValues::STONE_SLAB_TYPE_3_GRANITE => VanillaBlocks::GRANITE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_3_POLISHED_ANDESITE => VanillaBlocks::POLISHED_ANDESITE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_3_POLISHED_DIORITE => VanillaBlocks::POLISHED_DIORITE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_3_POLISHED_GRANITE => VanillaBlocks::POLISHED_GRANITE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_3_SMOOTH_RED_SANDSTONE => VanillaBlocks::SMOOTH_RED_SANDSTONE_SLAB(),
-			default => throw $in->badValueException(BlockStateNames::STONE_SLAB_TYPE_3, $type),
-		};
-	}
-
-	/** @throws BlockStateDeserializeException */
-	public static function mapStoneSlab4Type(BlockStateReader $in) : Slab{
-		// * stone_slab_type_4 (StringTag) = cut_red_sandstone, cut_sandstone, mossy_stone_brick, smooth_quartz, stone
-		return match($type = $in->readString(BlockStateNames::STONE_SLAB_TYPE_4)){
-			StringValues::STONE_SLAB_TYPE_4_CUT_RED_SANDSTONE => VanillaBlocks::CUT_RED_SANDSTONE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_4_CUT_SANDSTONE => VanillaBlocks::CUT_SANDSTONE_SLAB(),
-			StringValues::STONE_SLAB_TYPE_4_MOSSY_STONE_BRICK => VanillaBlocks::MOSSY_STONE_BRICK_SLAB(),
-			StringValues::STONE_SLAB_TYPE_4_SMOOTH_QUARTZ => VanillaBlocks::SMOOTH_QUARTZ_SLAB(),
-			StringValues::STONE_SLAB_TYPE_4_STONE => VanillaBlocks::STONE_SLAB(),
-			default => throw $in->badValueException(BlockStateNames::STONE_SLAB_TYPE_4, $type),
-		};
-	}
-
-	/** @throws BlockStateDeserializeException */
-	public static function mapWoodenSlabType(BlockStateReader $in) : Slab{
-		// * wood_type (StringTag) = acacia, birch, dark_oak, jungle, oak, spruce
-		return match($type = $in->readString(BlockStateNames::WOOD_TYPE)){
-			StringValues::WOOD_TYPE_ACACIA => VanillaBlocks::ACACIA_SLAB(),
-			StringValues::WOOD_TYPE_BIRCH => VanillaBlocks::BIRCH_SLAB(),
-			StringValues::WOOD_TYPE_DARK_OAK => VanillaBlocks::DARK_OAK_SLAB(),
-			StringValues::WOOD_TYPE_JUNGLE => VanillaBlocks::JUNGLE_SLAB(),
-			StringValues::WOOD_TYPE_OAK => VanillaBlocks::OAK_SLAB(),
-			StringValues::WOOD_TYPE_SPRUCE => VanillaBlocks::SPRUCE_SLAB(),
-			default => throw $in->badValueException(BlockStateNames::WOOD_TYPE, $type),
-		};
-	}
 }

src/data/bedrock/block/convert/BlockStateReader.php

@@ -24,8 +24,6 @@ declare(strict_types=1);
 namespace pocketmine\data\bedrock\block\convert;
 
 use pocketmine\block\utils\BellAttachmentType;
-use pocketmine\block\utils\CoralType;
-use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\SlabType;
 use pocketmine\block\utils\WallConnectionType;
 use pocketmine\data\bedrock\block\BlockLegacyMetadata;
@@ -39,20 +37,24 @@ use pocketmine\nbt\tag\ByteTag;
 use pocketmine\nbt\tag\IntTag;
 use pocketmine\nbt\tag\StringTag;
 use pocketmine\nbt\tag\Tag;
-use pocketmine\utils\Utils;
+use function array_keys;
+use function count;
 use function get_class;
+use function implode;
 
 final class BlockStateReader{
 
 	/**
-	 * @var true[]
-	 * @phpstan-var array<string, true>
+	 * @var Tag[]
+	 * @phpstan-var array<string, Tag>
 	 */
-	private array $usedStates = [];
+	private array $unusedStates;
 
 	public function __construct(
 		private BlockStateData $data
-	){}
+	){
+		$this->unusedStates = $this->data->getStates();
+	}
 
 	public function missingOrWrongTypeException(string $name, ?Tag $tag) : BlockStateDeserializeException{
 		return new BlockStateDeserializeException("Property \"$name\" " . ($tag !== null ? "has unexpected type " . get_class($tag) : "is missing"));
@@ -67,7 +69,7 @@ final class BlockStateReader{
 
 	/** @throws BlockStateDeserializeException */
 	public function readBool(string $name) : bool{
-		$this->usedStates[$name] = true;
+		unset($this->unusedStates[$name]);
 		$tag = $this->data->getState($name);
 		if($tag instanceof ByteTag){
 			switch($tag->getValue()){
@@ -81,7 +83,7 @@ final class BlockStateReader{
 
 	/** @throws BlockStateDeserializeException */
 	public function readInt(string $name) : int{
-		$this->usedStates[$name] = true;
+		unset($this->unusedStates[$name]);
 		$tag = $this->data->getState($name);
 		if($tag instanceof IntTag){
 			return $tag->getValue();
@@ -100,7 +102,7 @@ final class BlockStateReader{
 
 	/** @throws BlockStateDeserializeException */
 	public function readString(string $name) : string{
-		$this->usedStates[$name] = true;
+		unset($this->unusedStates[$name]);
 		//TODO: only allow a specific set of values (strings are primarily used for enums)
 		$tag = $this->data->getState($name);
 		if($tag instanceof StringTag){
@@ -236,30 +238,6 @@ final class BlockStateReader{
 		};
 	}
 
-	/** @throws BlockStateDeserializeException */
-	public function readColor() : DyeColor{
-		//	 * color (StringTag) = black, blue, brown, cyan, gray, green, light_blue, lime, magenta, orange, pink, purple, red, silver, white, yellow
-		return match($color = $this->readString(BlockStateNames::COLOR)){
-			StringValues::COLOR_BLACK => DyeColor::BLACK,
-			StringValues::COLOR_BLUE => DyeColor::BLUE,
-			StringValues::COLOR_BROWN => DyeColor::BROWN,
-			StringValues::COLOR_CYAN => DyeColor::CYAN,
-			StringValues::COLOR_GRAY => DyeColor::GRAY,
-			StringValues::COLOR_GREEN => DyeColor::GREEN,
-			StringValues::COLOR_LIGHT_BLUE => DyeColor::LIGHT_BLUE,
-			StringValues::COLOR_LIME => DyeColor::LIME,
-			StringValues::COLOR_MAGENTA => DyeColor::MAGENTA,
-			StringValues::COLOR_ORANGE => DyeColor::ORANGE,
-			StringValues::COLOR_PINK => DyeColor::PINK,
-			StringValues::COLOR_PURPLE => DyeColor::PURPLE,
-			StringValues::COLOR_RED => DyeColor::RED,
-			StringValues::COLOR_SILVER => DyeColor::LIGHT_GRAY,
-			StringValues::COLOR_WHITE => DyeColor::WHITE,
-			StringValues::COLOR_YELLOW => DyeColor::YELLOW,
-			default => throw $this->badValueException(BlockStateNames::COLOR, $color),
-		};
-	}
-
 	/** @throws BlockStateDeserializeException */
 	public function readCoralFacing() : int{
 		return $this->parseFacingValue($this->readInt(BlockStateNames::CORAL_DIRECTION), [
@@ -330,18 +308,6 @@ final class BlockStateReader{
 		};
 	}
 
-	/** @throws BlockStateDeserializeException */
-	public function readCoralType() : CoralType{
-		return match($type = $this->readString(BlockStateNames::CORAL_COLOR)){
-			StringValues::CORAL_COLOR_BLUE => CoralType::TUBE,
-			StringValues::CORAL_COLOR_PINK => CoralType::BRAIN,
-			StringValues::CORAL_COLOR_PURPLE => CoralType::BUBBLE,
-			StringValues::CORAL_COLOR_RED => CoralType::FIRE,
-			StringValues::CORAL_COLOR_YELLOW => CoralType::HORN,
-			default => throw $this->badValueException(BlockStateNames::CORAL_COLOR, $type),
-		};
-	}
-
 	/** @throws BlockStateDeserializeException */
 	public function readBellAttachmentType() : BellAttachmentType{
 		return match($type = $this->readString(BlockStateNames::ATTACHMENT)){
@@ -371,7 +337,7 @@ final class BlockStateReader{
 	 */
 	public function ignored(string $name) : void{
 		if($this->data->getState($name) !== null){
-			$this->usedStates[$name] = true;
+			unset($this->unusedStates[$name]);
 		}else{
 			throw $this->missingOrWrongTypeException($name, null);
 		}
@@ -388,10 +354,8 @@ final class BlockStateReader{
 	 * @throws BlockStateDeserializeException
 	 */
 	public function checkUnreadProperties() : void{
-		foreach(Utils::stringifyKeys($this->data->getStates()) as $name => $tag){
-			if(!isset($this->usedStates[$name])){
-				throw new BlockStateDeserializeException("Unread property \"$name\"");
-			}
+		if(count($this->unusedStates) > 0){
+			throw new BlockStateDeserializeException("Unread properties: " . implode(", ", array_keys($this->unusedStates)));
 		}
 	}
 }

src/data/bedrock/block/convert/BlockStateSerializerHelper.php

@@ -56,43 +56,35 @@ use pocketmine\data\bedrock\MushroomBlockTypeIdMap;
 use pocketmine\math\Facing;
 
 final class BlockStateSerializerHelper{
-
-	public static function encodeAllSidedLog(Wood $block) : BlockStateWriter{
-		return BlockStateWriter::create(Ids::WOOD)
-			->writeBool(BlockStateNames::STRIPPED_BIT, $block->isStripped())
-			->writePillarAxis($block->getAxis())
-			->writeLegacyWoodType($block->getWoodType());
-	}
-
-	public static function encodeButton(Button $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeButton(Button $block, Writer $out) : Writer{
 		return $out
 			->writeFacingDirection($block->getFacing())
 			->writeBool(BlockStateNames::BUTTON_PRESSED_BIT, $block->isPressed());
 	}
 
-	public static function encodeCandle(Candle $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeCandle(Candle $block, Writer $out) : Writer{
 		return $out
 			->writeBool(StateNames::LIT, $block->isLit())
 			->writeInt(StateNames::CANDLES, $block->getCount() - 1);
 	}
 
-	public static function encodeChemistryTable(ChemistryTable $block, string $chemistryTableType, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeChemistryTable(ChemistryTable $block, string $chemistryTableType, Writer $out) : Writer{
 		return $out
 			->writeString(BlockStateNames::CHEMISTRY_TABLE_TYPE, $chemistryTableType)
 			->writeLegacyHorizontalFacing(Facing::opposite($block->getFacing()));
 	}
 
-	public static function encodeCrops(Crops $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeCrops(Crops $block, Writer $out) : Writer{
 		return $out->writeInt(BlockStateNames::GROWTH, $block->getAge());
 	}
 
-	public static function encodeColoredTorch(Torch $block, bool $highBit, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeColoredTorch(Torch $block, bool $highBit, Writer $out) : Writer{
 		return $out
 			->writeBool(BlockStateNames::COLOR_BIT, $highBit)
 			->writeTorchFacing($block->getFacing());
 	}
 
-	public static function encodeCauldron(string $liquid, int $fillLevel) : BlockStateWriter{
+	public static function encodeCauldron(string $liquid, int $fillLevel) : Writer{
 		return Writer::create(Ids::CAULDRON)
 			->writeString(BlockStateNames::CAULDRON_LIQUID, $liquid)
 			->writeInt(BlockStateNames::FILL_LEVEL, $fillLevel);
@@ -107,7 +99,7 @@ final class BlockStateSerializerHelper{
 		};
 	}
 
-	public static function encodeDoor(Door $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeDoor(Door $block, Writer $out) : Writer{
 		return $out
 			->writeBool(BlockStateNames::UPPER_BLOCK_BIT, $block->isTop())
 			->writeLegacyHorizontalFacing(Facing::rotateY($block->getFacing(), true))
@@ -115,111 +107,100 @@ final class BlockStateSerializerHelper{
 			->writeBool(BlockStateNames::OPEN_BIT, $block->isOpen());
 	}
 
-	public static function encodeDoublePlant(DoublePlant $block, string $doublePlantType, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeDoublePlant(DoublePlant $block, Writer $out) : Writer{
 		return $out
-			->writeBool(BlockStateNames::UPPER_BLOCK_BIT, $block->isTop())
-			->writeString(BlockStateNames::DOUBLE_PLANT_TYPE, $doublePlantType);
+			->writeBool(BlockStateNames::UPPER_BLOCK_BIT, $block->isTop());
 	}
 
-	public static function encodeFenceGate(FenceGate $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeFenceGate(FenceGate $block, Writer $out) : Writer{
 		return $out
 			->writeLegacyHorizontalFacing($block->getFacing())
 			->writeBool(BlockStateNames::IN_WALL_BIT, $block->isInWall())
 			->writeBool(BlockStateNames::OPEN_BIT, $block->isOpen());
 	}
 
-	public static function encodeFloorSign(FloorSign $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeFloorSign(FloorSign $block, Writer $out) : Writer{
 		return $out
 			->writeInt(BlockStateNames::GROUND_SIGN_DIRECTION, $block->getRotation());
 	}
 
-	public static function encodeFurnace(Furnace $block, string $unlitId, string $litId) : BlockStateWriter{
-		return BlockStateWriter::create($block->isLit() ? $litId : $unlitId)
+	public static function encodeFurnace(Furnace $block, string $unlitId, string $litId) : Writer{
+		return Writer::create($block->isLit() ? $litId : $unlitId)
 			->writeCardinalHorizontalFacing($block->getFacing());
 	}
 
-	public static function encodeItemFrame(ItemFrame $block, string $id) : BlockStateWriter{
+	public static function encodeItemFrame(ItemFrame $block, string $id) : Writer{
 		return Writer::create($id)
 			->writeBool(StateNames::ITEM_FRAME_MAP_BIT, $block->hasMap())
 			->writeBool(StateNames::ITEM_FRAME_PHOTO_BIT, false)
 			->writeFacingDirection($block->getFacing());
 	}
 
-	public static function encodeLeaves(Leaves $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeLeaves(Leaves $block, Writer $out) : Writer{
 		return $out
 			->writeBool(BlockStateNames::PERSISTENT_BIT, $block->isNoDecay())
 			->writeBool(BlockStateNames::UPDATE_BIT, $block->isCheckDecay());
 	}
 
-	public static function encodeLeaves1(Leaves $block, string $type) : BlockStateWriter{
-		return self::encodeLeaves($block, BlockStateWriter::create(Ids::LEAVES)
-			->writeString(BlockStateNames::OLD_LEAF_TYPE, $type));
-	}
-
-	public static function encodeLeaves2(Leaves $block, string $type) : BlockStateWriter{
-		return self::encodeLeaves($block, BlockStateWriter::create(Ids::LEAVES2)
-			->writeString(BlockStateNames::NEW_LEAF_TYPE, $type));
-	}
-
-	public static function encodeLiquid(Liquid $block, string $stillId, string $flowingId) : BlockStateWriter{
-		return BlockStateWriter::create($block->isStill() ? $stillId : $flowingId)
+	public static function encodeLiquid(Liquid $block, string $stillId, string $flowingId) : Writer{
+		return Writer::create($block->isStill() ? $stillId : $flowingId)
 			->writeInt(BlockStateNames::LIQUID_DEPTH, $block->getDecay() | ($block->isFalling() ? 0x8 : 0));
 	}
 
-	public static function encodeLog(Wood $block, string $unstrippedId, string $strippedId) : BlockStateWriter{
+	public static function encodeLog(Wood $block, string $unstrippedId, string $strippedId) : Writer{
 		$out = $block->isStripped() ?
-			BlockStateWriter::create($strippedId) :
-			BlockStateWriter::create($unstrippedId);
+			Writer::create($strippedId) :
+			Writer::create($unstrippedId);
 		return $out
 			->writePillarAxis($block->getAxis());
 	}
 
-	public static function encodeMushroomBlock(RedMushroomBlock $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeMushroomBlock(RedMushroomBlock $block, Writer $out) : Writer{
 		return $out
 			->writeInt(BlockStateNames::HUGE_MUSHROOM_BITS, MushroomBlockTypeIdMap::getInstance()->toId($block->getMushroomBlockType()));
 	}
 
-	public static function encodeQuartz(string $type, int $axis) : BlockStateWriter{
-		return BlockStateWriter::create(Ids::QUARTZ_BLOCK)
-			->writeString(BlockStateNames::CHISEL_TYPE, $type)
+	public static function encodeQuartz(int $axis, Writer $out) : Writer{
+		return $out
 			->writePillarAxis($axis); //this isn't needed for all types, but we have to write it anyway
 	}
 
-	public static function encodeRedFlower(string $type) : BlockStateWriter{
-		return BlockStateWriter::create(Ids::RED_FLOWER)->writeString(BlockStateNames::FLOWER_TYPE, $type);
+	public static function encodeSapling(Sapling $block, Writer $out) : Writer{
+		return $out
+			->writeBool(BlockStateNames::AGE_BIT, $block->isReady());
 	}
 
-	public static function encodeSandstone(string $id, string $type) : BlockStateWriter{
-		return BlockStateWriter::create($id)->writeString(BlockStateNames::SAND_STONE_TYPE, $type);
-	}
-
-	public static function encodeSapling(Sapling $block, string $type) : BlockStateWriter{
-		return BlockStateWriter::create(Ids::SAPLING)
-			->writeBool(BlockStateNames::AGE_BIT, $block->isReady())
-			->writeString(BlockStateNames::SAPLING_TYPE, $type);
-	}
-
-	public static function encodeSimplePressurePlate(SimplePressurePlate $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeSimplePressurePlate(SimplePressurePlate $block, Writer $out) : Writer{
 		//TODO: not sure what the deal is here ... seems like a mojang bug / artifact of bad implementation?
 		//best to keep this separate from weighted plates anyway...
 		return $out
 			->writeInt(BlockStateNames::REDSTONE_SIGNAL, $block->isPressed() ? 15 : 0);
 	}
 
-	public static function encodeSlab(Slab $block, string $singleId, string $doubleId) : BlockStateWriter{
-		$slabType = $block->getSlabType();
-		return BlockStateWriter::create($slabType === SlabType::DOUBLE ? $doubleId : $singleId)
-			//this is (intentionally) also written for double slabs (as zero) to maintain bug parity with MCPE
-			->writeSlabPosition($slabType === SlabType::DOUBLE ? SlabType::BOTTOM : $slabType);
+	private static function encodeSingleSlab(Slab $block, string $id) : Writer{
+		return Writer::create($id)
+			->writeSlabPosition($block->getSlabType());
 	}
 
-	public static function encodeStairs(Stair $block, BlockStateWriter $out) : BlockStateWriter{
+	private static function encodeDoubleSlab(Slab $block, string $id) : Writer{
+		return Writer::create($id)
+			//this is (intentionally) also written for double slabs (as zero) to maintain bug parity with MCPE
+			->writeSlabPosition(SlabType::BOTTOM);
+	}
+
+	public static function encodeSlab(Slab $block, string $singleId, string $doubleId) : Writer{
+		return $block->getSlabType() === SlabType::DOUBLE ?
+			self::encodeDoubleSlab($block, $doubleId) :
+			self::encodeSingleSlab($block, $singleId);
+	}
+
+	public static function encodeStairs(Stair $block, Writer $out) : Writer{
 		return $out
 			->writeBool(BlockStateNames::UPSIDE_DOWN_BIT, $block->isUpsideDown())
 			->writeWeirdoHorizontalFacing($block->getFacing());
 	}
 
-	public static function encodeStem(Stem $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeStem(Stem $block, Writer $out) : Writer{
 		//In PM, we use Facing::UP to indicate that the stem is not attached to a pumpkin/melon, since this makes the
 		//most intuitive sense (the stem is pointing at the sky). However, Bedrock uses the DOWN state for this, which
 		//is absurd, and I refuse to make our API similarly absurd.
@@ -228,45 +209,14 @@ final class BlockStateSerializerHelper{
 			->writeFacingWithoutUp($facing === Facing::UP ? Facing::DOWN : $facing);
 	}
 
-	public static function encodeStone(string $type) : BlockStateWriter{
-		return BlockStateWriter::create(Ids::STONE)
-			->writeString(BlockStateNames::STONE_TYPE, $type);
-	}
-
-	public static function encodeStoneBricks(string $type) : BlockStateWriter{
-		return BlockStateWriter::create(Ids::STONEBRICK)
-			->writeString(BlockStateNames::STONE_BRICK_TYPE, $type);
-	}
-
-	private static function encodeStoneSlab(Slab $block, string $singleId, string $doubleId, string $typeKey, string $typeValue) : BlockStateWriter{
-		return self::encodeSlab($block, $singleId, $doubleId)
-			->writeString($typeKey, $typeValue);
-	}
-
-	public static function encodeStoneSlab1(Slab $block, string $typeValue) : BlockStateWriter{
-		return self::encodeStoneSlab($block, Ids::STONE_BLOCK_SLAB, Ids::DOUBLE_STONE_BLOCK_SLAB, BlockStateNames::STONE_SLAB_TYPE, $typeValue);
-	}
-
-	public static function encodeStoneSlab2(Slab $block, string $typeValue) : BlockStateWriter{
-		return self::encodeStoneSlab($block, Ids::STONE_BLOCK_SLAB2, Ids::DOUBLE_STONE_BLOCK_SLAB2, BlockStateNames::STONE_SLAB_TYPE_2, $typeValue);
-	}
-
-	public static function encodeStoneSlab3(Slab $block, string $typeValue) : BlockStateWriter{
-		return self::encodeStoneSlab($block, Ids::STONE_BLOCK_SLAB3, Ids::DOUBLE_STONE_BLOCK_SLAB3, BlockStateNames::STONE_SLAB_TYPE_3, $typeValue);
-	}
-
-	public static function encodeStoneSlab4(Slab $block, string $typeValue) : BlockStateWriter{
-		return self::encodeStoneSlab($block, Ids::STONE_BLOCK_SLAB4, Ids::DOUBLE_STONE_BLOCK_SLAB4, BlockStateNames::STONE_SLAB_TYPE_4, $typeValue);
-	}
-
-	public static function encodeTrapdoor(Trapdoor $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeTrapdoor(Trapdoor $block, Writer $out) : Writer{
 		return $out
 			->write5MinusHorizontalFacing($block->getFacing())
 			->writeBool(BlockStateNames::UPSIDE_DOWN_BIT, $block->isTop())
 			->writeBool(BlockStateNames::OPEN_BIT, $block->isOpen());
 	}
 
-	public static function encodeWall(Wall $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeWall(Wall $block, Writer $out) : Writer{
 		return $out
 			->writeBool(BlockStateNames::WALL_POST_BIT, $block->isPost())
 			->writeWallConnectionType(BlockStateNames::WALL_CONNECTION_TYPE_EAST, $block->getConnection(Facing::EAST))
@@ -275,18 +225,13 @@ final class BlockStateSerializerHelper{
 			->writeWallConnectionType(BlockStateNames::WALL_CONNECTION_TYPE_WEST, $block->getConnection(Facing::WEST));
 	}
 
-	public static function encodeLegacyWall(Wall $block, string $type) : BlockStateWriter{
-		return self::encodeWall($block, BlockStateWriter::create(Ids::COBBLESTONE_WALL))
+	public static function encodeLegacyWall(Wall $block, string $type) : Writer{
+		return self::encodeWall($block, Writer::create(Ids::COBBLESTONE_WALL))
 			->writeString(BlockStateNames::WALL_BLOCK_TYPE, $type);
 	}
 
-	public static function encodeWallSign(WallSign $block, BlockStateWriter $out) : BlockStateWriter{
+	public static function encodeWallSign(WallSign $block, Writer $out) : Writer{
 		return $out
 			->writeHorizontalFacing($block->getFacing());
 	}
-
-	public static function encodeWoodenSlab(Slab $block, string $typeValue) : BlockStateWriter{
-		return self::encodeSlab($block, Ids::WOODEN_SLAB, Ids::DOUBLE_WOODEN_SLAB)
-			->writeString(BlockStateNames::WOOD_TYPE, $typeValue);
-	}
 }

src/data/bedrock/block/convert/BlockStateToObjectDeserializer.php

@@ -24,12 +24,13 @@ declare(strict_types=1);
 namespace pocketmine\data\bedrock\block\convert;
 
 use pocketmine\block\AmethystCluster;
+use pocketmine\block\Anvil;
 use pocketmine\block\Bamboo;
 use pocketmine\block\Block;
 use pocketmine\block\CaveVines;
 use pocketmine\block\ChorusFlower;
 use pocketmine\block\DoublePitcherCrop;
-use pocketmine\block\Light;
+use pocketmine\block\Opaque;
 use pocketmine\block\PinkPetals;
 use pocketmine\block\PitcherCrop;
 use pocketmine\block\Slab;
@@ -44,7 +45,6 @@ use pocketmine\block\utils\DripleafState;
 use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\FroglightType;
 use pocketmine\block\utils\LeverFacing;
-use pocketmine\block\utils\SlabType;
 use pocketmine\block\VanillaBlocks as Blocks;
 use pocketmine\block\Wood;
 use pocketmine\data\bedrock\block\BlockLegacyMetadata;
@@ -82,8 +82,9 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->registerFlatCoralDeserializers();
 		$this->registerCauldronDeserializers();
 		$this->registerFlatWoodBlockDeserializers();
-		$this->registerLegacyWoodBlockDeserializers();
 		$this->registerLeavesDeserializers();
+		$this->registerSaplingDeserializers();
+		$this->registerLightDeserializers();
 		$this->registerSimpleDeserializers();
 		$this->registerDeserializers();
 	}
@@ -115,11 +116,8 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 	 * @phpstan-param \Closure(Reader) : Slab $getBlock
 	 */
 	public function mapSlab(string $singleId, string $doubleId, \Closure $getBlock) : void{
-		$this->map($singleId, fn(Reader $in) : Slab => $getBlock($in)->setSlabType($in->readSlabPosition()));
-		$this->map($doubleId, function(Reader $in) use ($getBlock) : Slab{
-			$in->ignored(StateNames::MC_VERTICAL_HALF);
-			return $getBlock($in)->setSlabType(SlabType::DOUBLE);
-		});
+		$this->map($singleId, fn(Reader $in) => Helper::decodeSingleSlab($getBlock($in), $in));
+		$this->map($doubleId, fn(Reader $in) => Helper::decodeDoubleSlab($getBlock($in), $in));
 	}
 
 	/**
@@ -185,6 +183,48 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 	}
 
 	private function registerFlatColorBlockDeserializers() : void{
+		foreach([
+			Ids::HARD_BLACK_STAINED_GLASS => DyeColor::BLACK,
+			Ids::HARD_BLUE_STAINED_GLASS => DyeColor::BLUE,
+			Ids::HARD_BROWN_STAINED_GLASS => DyeColor::BROWN,
+			Ids::HARD_CYAN_STAINED_GLASS => DyeColor::CYAN,
+			Ids::HARD_GRAY_STAINED_GLASS => DyeColor::GRAY,
+			Ids::HARD_GREEN_STAINED_GLASS => DyeColor::GREEN,
+			Ids::HARD_LIGHT_BLUE_STAINED_GLASS => DyeColor::LIGHT_BLUE,
+			Ids::HARD_LIGHT_GRAY_STAINED_GLASS => DyeColor::LIGHT_GRAY,
+			Ids::HARD_LIME_STAINED_GLASS => DyeColor::LIME,
+			Ids::HARD_MAGENTA_STAINED_GLASS => DyeColor::MAGENTA,
+			Ids::HARD_ORANGE_STAINED_GLASS => DyeColor::ORANGE,
+			Ids::HARD_PINK_STAINED_GLASS => DyeColor::PINK,
+			Ids::HARD_PURPLE_STAINED_GLASS => DyeColor::PURPLE,
+			Ids::HARD_RED_STAINED_GLASS => DyeColor::RED,
+			Ids::HARD_WHITE_STAINED_GLASS => DyeColor::WHITE,
+			Ids::HARD_YELLOW_STAINED_GLASS => DyeColor::YELLOW,
+		] as $id => $color){
+			$this->map($id, fn(Reader $in) => Blocks::STAINED_HARDENED_GLASS()->setColor($color));
+		}
+
+		foreach([
+			Ids::HARD_BLACK_STAINED_GLASS_PANE => DyeColor::BLACK,
+			Ids::HARD_BLUE_STAINED_GLASS_PANE => DyeColor::BLUE,
+			Ids::HARD_BROWN_STAINED_GLASS_PANE => DyeColor::BROWN,
+			Ids::HARD_CYAN_STAINED_GLASS_PANE => DyeColor::CYAN,
+			Ids::HARD_GRAY_STAINED_GLASS_PANE => DyeColor::GRAY,
+			Ids::HARD_GREEN_STAINED_GLASS_PANE => DyeColor::GREEN,
+			Ids::HARD_LIGHT_BLUE_STAINED_GLASS_PANE => DyeColor::LIGHT_BLUE,
+			Ids::HARD_LIGHT_GRAY_STAINED_GLASS_PANE => DyeColor::LIGHT_GRAY,
+			Ids::HARD_LIME_STAINED_GLASS_PANE => DyeColor::LIME,
+			Ids::HARD_MAGENTA_STAINED_GLASS_PANE => DyeColor::MAGENTA,
+			Ids::HARD_ORANGE_STAINED_GLASS_PANE => DyeColor::ORANGE,
+			Ids::HARD_PINK_STAINED_GLASS_PANE => DyeColor::PINK,
+			Ids::HARD_PURPLE_STAINED_GLASS_PANE => DyeColor::PURPLE,
+			Ids::HARD_RED_STAINED_GLASS_PANE => DyeColor::RED,
+			Ids::HARD_WHITE_STAINED_GLASS_PANE => DyeColor::WHITE,
+			Ids::HARD_YELLOW_STAINED_GLASS_PANE => DyeColor::YELLOW,
+		] as $id => $color){
+			$this->map($id, fn(Reader $in) => Blocks::STAINED_HARDENED_GLASS_PANE()->setColor($color));
+		}
+
 		foreach([
 			Ids::BLACK_GLAZED_TERRACOTTA => DyeColor::BLACK,
 			Ids::BLUE_GLAZED_TERRACOTTA => DyeColor::BLUE,
@@ -397,6 +437,39 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		] as $id => $coralType){
 			$this->mapSimple($id, fn() => Blocks::CORAL()->setCoralType($coralType)->setDead(true));
 		}
+
+		foreach([
+			[CoralType::BRAIN, Ids::BRAIN_CORAL_FAN, Ids::DEAD_BRAIN_CORAL_FAN],
+			[CoralType::BUBBLE, Ids::BUBBLE_CORAL_FAN, Ids::DEAD_BUBBLE_CORAL_FAN],
+			[CoralType::FIRE, Ids::FIRE_CORAL_FAN, Ids::DEAD_FIRE_CORAL_FAN],
+			[CoralType::HORN, Ids::HORN_CORAL_FAN, Ids::DEAD_HORN_CORAL_FAN],
+			[CoralType::TUBE, Ids::TUBE_CORAL_FAN, Ids::DEAD_TUBE_CORAL_FAN],
+		] as [$coralType, $aliveId, $deadId]){
+			$this->map($aliveId, fn(Reader $in) => Helper::decodeFloorCoralFan(Blocks::CORAL_FAN()->setCoralType($coralType)->setDead(false), $in));
+			$this->map($deadId, fn(Reader $in) => Helper::decodeFloorCoralFan(Blocks::CORAL_FAN()->setCoralType($coralType)->setDead(true), $in));
+		}
+
+		foreach([
+			[CoralType::BRAIN, Ids::BRAIN_CORAL_BLOCK, Ids::DEAD_BRAIN_CORAL_BLOCK],
+			[CoralType::BUBBLE, Ids::BUBBLE_CORAL_BLOCK, Ids::DEAD_BUBBLE_CORAL_BLOCK],
+			[CoralType::FIRE, Ids::FIRE_CORAL_BLOCK, Ids::DEAD_FIRE_CORAL_BLOCK],
+			[CoralType::HORN, Ids::HORN_CORAL_BLOCK, Ids::DEAD_HORN_CORAL_BLOCK],
+			[CoralType::TUBE, Ids::TUBE_CORAL_BLOCK, Ids::DEAD_TUBE_CORAL_BLOCK],
+		] as [$coralType, $aliveId, $deadId]){
+			$this->map($aliveId, fn(Reader $in) => Blocks::CORAL_BLOCK()->setCoralType($coralType)->setDead(false));
+			$this->map($deadId, fn(Reader $in) => Blocks::CORAL_BLOCK()->setCoralType($coralType)->setDead(true));
+		}
+
+		foreach([
+			[CoralType::BRAIN, Ids::BRAIN_CORAL_WALL_FAN, Ids::DEAD_BRAIN_CORAL_WALL_FAN],
+			[CoralType::BUBBLE, Ids::BUBBLE_CORAL_WALL_FAN, Ids::DEAD_BUBBLE_CORAL_WALL_FAN],
+			[CoralType::FIRE, Ids::FIRE_CORAL_WALL_FAN, Ids::DEAD_FIRE_CORAL_WALL_FAN],
+			[CoralType::HORN, Ids::HORN_CORAL_WALL_FAN, Ids::DEAD_HORN_CORAL_WALL_FAN],
+			[CoralType::TUBE, Ids::TUBE_CORAL_WALL_FAN, Ids::DEAD_TUBE_CORAL_WALL_FAN],
+		] as [$coralType, $aliveId, $deadId]){
+			$this->map($aliveId, fn(Reader $in) => Blocks::WALL_CORAL_FAN()->setFacing($in->readCoralFacing())->setCoralType($coralType)->setDead(false));
+			$this->map($deadId, fn(Reader $in) => Blocks::WALL_CORAL_FAN()->setFacing($in->readCoralFacing())->setCoralType($coralType)->setDead(true));
+		}
 	}
 
 	private function registerCauldronDeserializers() : void{
@@ -426,9 +499,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->map(Ids::ACACIA_TRAPDOOR, fn(Reader $in) => Helper::decodeTrapdoor(Blocks::ACACIA_TRAPDOOR(), $in));
 		$this->map(Ids::ACACIA_WALL_SIGN, fn(Reader $in) => Helper::decodeWallSign(Blocks::ACACIA_WALL_SIGN(), $in));
 		$this->mapLog(Ids::ACACIA_LOG, Ids::STRIPPED_ACACIA_LOG, fn() => Blocks::ACACIA_LOG());
+		$this->mapLog(Ids::ACACIA_WOOD, Ids::STRIPPED_ACACIA_WOOD, fn() => Blocks::ACACIA_WOOD());
 		$this->mapSimple(Ids::ACACIA_FENCE, fn() => Blocks::ACACIA_FENCE());
+		$this->mapSimple(Ids::ACACIA_PLANKS, fn() => Blocks::ACACIA_PLANKS());
+		$this->mapSlab(Ids::ACACIA_SLAB, Ids::ACACIA_DOUBLE_SLAB, fn() => Blocks::ACACIA_SLAB());
 		$this->mapStairs(Ids::ACACIA_STAIRS, fn() => Blocks::ACACIA_STAIRS());
-		//wood, planks and slabs still use the old way of storing wood type
 
 		$this->map(Ids::BIRCH_BUTTON, fn(Reader $in) => Helper::decodeButton(Blocks::BIRCH_BUTTON(), $in));
 		$this->map(Ids::BIRCH_DOOR, fn(Reader $in) => Helper::decodeDoor(Blocks::BIRCH_DOOR(), $in));
@@ -438,9 +513,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->map(Ids::BIRCH_TRAPDOOR, fn(Reader $in) => Helper::decodeTrapdoor(Blocks::BIRCH_TRAPDOOR(), $in));
 		$this->map(Ids::BIRCH_WALL_SIGN, fn(Reader $in) => Helper::decodeWallSign(Blocks::BIRCH_WALL_SIGN(), $in));
 		$this->mapLog(Ids::BIRCH_LOG, Ids::STRIPPED_BIRCH_LOG, fn() => Blocks::BIRCH_LOG());
+		$this->mapLog(Ids::BIRCH_WOOD, Ids::STRIPPED_BIRCH_WOOD, fn() => Blocks::BIRCH_WOOD());
 		$this->mapSimple(Ids::BIRCH_FENCE, fn() => Blocks::BIRCH_FENCE());
+		$this->mapSimple(Ids::BIRCH_PLANKS, fn() => Blocks::BIRCH_PLANKS());
+		$this->mapSlab(Ids::BIRCH_SLAB, Ids::BIRCH_DOUBLE_SLAB, fn() => Blocks::BIRCH_SLAB());
 		$this->mapStairs(Ids::BIRCH_STAIRS, fn() => Blocks::BIRCH_STAIRS());
-		//wood, planks and slabs still use the old way of storing wood type
 
 		$this->map(Ids::CHERRY_BUTTON, fn(Reader $in) => Helper::decodeButton(Blocks::CHERRY_BUTTON(), $in));
 		$this->map(Ids::CHERRY_DOOR, fn(Reader $in) => Helper::decodeDoor(Blocks::CHERRY_DOOR(), $in));
@@ -482,9 +559,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->map(Ids::DARK_OAK_PRESSURE_PLATE, fn(Reader $in) => Helper::decodeSimplePressurePlate(Blocks::DARK_OAK_PRESSURE_PLATE(), $in));
 		$this->map(Ids::DARK_OAK_TRAPDOOR, fn(Reader $in) => Helper::decodeTrapdoor(Blocks::DARK_OAK_TRAPDOOR(), $in));
 		$this->mapLog(Ids::DARK_OAK_LOG, Ids::STRIPPED_DARK_OAK_LOG, fn() => Blocks::DARK_OAK_LOG());
+		$this->mapLog(Ids::DARK_OAK_WOOD, Ids::STRIPPED_DARK_OAK_WOOD, fn() => Blocks::DARK_OAK_WOOD());
 		$this->mapSimple(Ids::DARK_OAK_FENCE, fn() => Blocks::DARK_OAK_FENCE());
+		$this->mapSimple(Ids::DARK_OAK_PLANKS, fn() => Blocks::DARK_OAK_PLANKS());
+		$this->mapSlab(Ids::DARK_OAK_SLAB, Ids::DARK_OAK_DOUBLE_SLAB, fn() => Blocks::DARK_OAK_SLAB());
 		$this->mapStairs(Ids::DARK_OAK_STAIRS, fn() => Blocks::DARK_OAK_STAIRS());
-		//wood, planks and slabs still use the old way of storing wood type
 
 		$this->map(Ids::JUNGLE_BUTTON, fn(Reader $in) => Helper::decodeButton(Blocks::JUNGLE_BUTTON(), $in));
 		$this->map(Ids::JUNGLE_DOOR, fn(Reader $in) => Helper::decodeDoor(Blocks::JUNGLE_DOOR(), $in));
@@ -494,9 +573,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->map(Ids::JUNGLE_TRAPDOOR, fn(Reader $in) => Helper::decodeTrapdoor(Blocks::JUNGLE_TRAPDOOR(), $in));
 		$this->map(Ids::JUNGLE_WALL_SIGN, fn(Reader $in) => Helper::decodeWallSign(Blocks::JUNGLE_WALL_SIGN(), $in));
 		$this->mapLog(Ids::JUNGLE_LOG, Ids::STRIPPED_JUNGLE_LOG, fn() => Blocks::JUNGLE_LOG());
+		$this->mapLog(Ids::JUNGLE_WOOD, Ids::STRIPPED_JUNGLE_WOOD, fn() => Blocks::JUNGLE_WOOD());
 		$this->mapSimple(Ids::JUNGLE_FENCE, fn() => Blocks::JUNGLE_FENCE());
+		$this->mapSimple(Ids::JUNGLE_PLANKS, fn() => Blocks::JUNGLE_PLANKS());
+		$this->mapSlab(Ids::JUNGLE_SLAB, Ids::JUNGLE_DOUBLE_SLAB, fn() => Blocks::JUNGLE_SLAB());
 		$this->mapStairs(Ids::JUNGLE_STAIRS, fn() => Blocks::JUNGLE_STAIRS());
-		//wood, planks and slabs still use the old way of storing wood type
 
 		$this->map(Ids::MANGROVE_BUTTON, fn(Reader $in) => Helper::decodeButton(Blocks::MANGROVE_BUTTON(), $in));
 		$this->map(Ids::MANGROVE_DOOR, fn(Reader $in) => Helper::decodeDoor(Blocks::MANGROVE_DOOR(), $in));
@@ -525,9 +606,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->map(Ids::TRAPDOOR, fn(Reader $in) => Helper::decodeTrapdoor(Blocks::OAK_TRAPDOOR(), $in));
 		$this->map(Ids::WALL_SIGN, fn(Reader $in) => Helper::decodeWallSign(Blocks::OAK_WALL_SIGN(), $in));
 		$this->mapLog(Ids::OAK_LOG, Ids::STRIPPED_OAK_LOG, fn() => Blocks::OAK_LOG());
+		$this->mapLog(Ids::OAK_WOOD, Ids::STRIPPED_OAK_WOOD, fn() => Blocks::OAK_WOOD());
 		$this->mapSimple(Ids::OAK_FENCE, fn() => Blocks::OAK_FENCE());
+		$this->mapSimple(Ids::OAK_PLANKS, fn() => Blocks::OAK_PLANKS());
+		$this->mapSlab(Ids::OAK_SLAB, Ids::OAK_DOUBLE_SLAB, fn() => Blocks::OAK_SLAB());
 		$this->mapStairs(Ids::OAK_STAIRS, fn() => Blocks::OAK_STAIRS());
-		//wood, planks and slabs still use the old way of storing wood type
 
 		$this->map(Ids::SPRUCE_BUTTON, fn(Reader $in) => Helper::decodeButton(Blocks::SPRUCE_BUTTON(), $in));
 		$this->map(Ids::SPRUCE_DOOR, fn(Reader $in) => Helper::decodeDoor(Blocks::SPRUCE_DOOR(), $in));
@@ -537,9 +620,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->map(Ids::SPRUCE_TRAPDOOR, fn(Reader $in) => Helper::decodeTrapdoor(Blocks::SPRUCE_TRAPDOOR(), $in));
 		$this->map(Ids::SPRUCE_WALL_SIGN, fn(Reader $in) => Helper::decodeWallSign(Blocks::SPRUCE_WALL_SIGN(), $in));
 		$this->mapLog(Ids::SPRUCE_LOG, Ids::STRIPPED_SPRUCE_LOG, fn() => Blocks::SPRUCE_LOG());
+		$this->mapLog(Ids::SPRUCE_WOOD, Ids::STRIPPED_SPRUCE_WOOD, fn() => Blocks::SPRUCE_WOOD());
 		$this->mapSimple(Ids::SPRUCE_FENCE, fn() => Blocks::SPRUCE_FENCE());
+		$this->mapSimple(Ids::SPRUCE_PLANKS, fn() => Blocks::SPRUCE_PLANKS());
+		$this->mapSlab(Ids::SPRUCE_SLAB, Ids::SPRUCE_DOUBLE_SLAB, fn() => Blocks::SPRUCE_SLAB());
 		$this->mapStairs(Ids::SPRUCE_STAIRS, fn() => Blocks::SPRUCE_STAIRS());
-		//wood, planks and slabs still use the old way of storing wood type
 
 		$this->map(Ids::WARPED_BUTTON, fn(Reader $in) => Helper::decodeButton(Blocks::WARPED_BUTTON(), $in));
 		$this->map(Ids::WARPED_DOOR, fn(Reader $in) => Helper::decodeDoor(Blocks::WARPED_DOOR(), $in));
@@ -556,58 +641,60 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapStairs(Ids::WARPED_STAIRS, fn() => Blocks::WARPED_STAIRS());
 	}
 
-	private function registerLegacyWoodBlockDeserializers() : void{
-
-		$this->map(Ids::PLANKS, function(Reader $in) : Block{
-			return match($woodName = $in->readString(StateNames::WOOD_TYPE)){
-				StringValues::WOOD_TYPE_OAK => Blocks::OAK_PLANKS(),
-				StringValues::WOOD_TYPE_SPRUCE => Blocks::SPRUCE_PLANKS(),
-				StringValues::WOOD_TYPE_BIRCH => Blocks::BIRCH_PLANKS(),
-				StringValues::WOOD_TYPE_JUNGLE => Blocks::JUNGLE_PLANKS(),
-				StringValues::WOOD_TYPE_ACACIA => Blocks::ACACIA_PLANKS(),
-				StringValues::WOOD_TYPE_DARK_OAK => Blocks::DARK_OAK_PLANKS(),
-				default => throw $in->badValueException(StateNames::WOOD_TYPE, $woodName),
-			};
-		});
-		$this->mapSlab(Ids::WOODEN_SLAB, Ids::DOUBLE_WOODEN_SLAB, fn(Reader $in) => Helper::mapWoodenSlabType($in));
-
-		$this->map(Ids::WOOD, fn(Reader $in) : Block => Helper::decodeLog(match($woodType = $in->readString(StateNames::WOOD_TYPE)){
-			StringValues::WOOD_TYPE_ACACIA => Blocks::ACACIA_WOOD(),
-			StringValues::WOOD_TYPE_BIRCH => Blocks::BIRCH_WOOD(),
-			StringValues::WOOD_TYPE_DARK_OAK => Blocks::DARK_OAK_WOOD(),
-			StringValues::WOOD_TYPE_JUNGLE => Blocks::JUNGLE_WOOD(),
-			StringValues::WOOD_TYPE_OAK => Blocks::OAK_WOOD(),
-			StringValues::WOOD_TYPE_SPRUCE => Blocks::SPRUCE_WOOD(),
-			default => throw $in->badValueException(StateNames::WOOD_TYPE, $woodType),
-		}, $in->readBool(StateNames::STRIPPED_BIT), $in));
-	}
-
 	private function registerLeavesDeserializers() : void{
-		//flattened IDs
+		$this->map(Ids::ACACIA_LEAVES, fn(Reader $in) => Helper::decodeLeaves(Blocks::ACACIA_LEAVES(), $in));
 		$this->map(Ids::AZALEA_LEAVES, fn(Reader $in) => Helper::decodeLeaves(Blocks::AZALEA_LEAVES(), $in));
 		$this->map(Ids::AZALEA_LEAVES_FLOWERED, fn(Reader $in) => Helper::decodeLeaves(Blocks::FLOWERING_AZALEA_LEAVES(), $in));
+		$this->map(Ids::BIRCH_LEAVES, fn(Reader $in) => Helper::decodeLeaves(Blocks::BIRCH_LEAVES(), $in));
 		$this->map(Ids::CHERRY_LEAVES, fn(Reader $in) => Helper::decodeLeaves(Blocks::CHERRY_LEAVES(), $in));
+		$this->map(Ids::DARK_OAK_LEAVES, fn(Reader $in) => Helper::decodeLeaves(Blocks::DARK_OAK_LEAVES(), $in));
+		$this->map(Ids::JUNGLE_LEAVES, fn(Reader $in) => Helper::decodeLeaves(Blocks::JUNGLE_LEAVES(), $in));
 		$this->map(Ids::MANGROVE_LEAVES, fn(Reader $in) => Helper::decodeLeaves(Blocks::MANGROVE_LEAVES(), $in));
+		$this->map(Ids::OAK_LEAVES, fn(Reader $in) => Helper::decodeLeaves(Blocks::OAK_LEAVES(), $in));
+		$this->map(Ids::SPRUCE_LEAVES, fn(Reader $in) => Helper::decodeLeaves(Blocks::SPRUCE_LEAVES(), $in));
+	}
 
-		//legacy mess
-		$this->map(Ids::LEAVES, fn(Reader $in) => Helper::decodeLeaves(match($type = $in->readString(StateNames::OLD_LEAF_TYPE)){
-			StringValues::OLD_LEAF_TYPE_BIRCH => Blocks::BIRCH_LEAVES(),
-			StringValues::OLD_LEAF_TYPE_JUNGLE => Blocks::JUNGLE_LEAVES(),
-			StringValues::OLD_LEAF_TYPE_OAK => Blocks::OAK_LEAVES(),
-			StringValues::OLD_LEAF_TYPE_SPRUCE => Blocks::SPRUCE_LEAVES(),
-			default => throw $in->badValueException(StateNames::OLD_LEAF_TYPE, $type),
-		}, $in));
-		$this->map(Ids::LEAVES2, fn(Reader $in) => Helper::decodeLeaves(match($type = $in->readString(StateNames::NEW_LEAF_TYPE)){
-			StringValues::NEW_LEAF_TYPE_ACACIA => Blocks::ACACIA_LEAVES(),
-			StringValues::NEW_LEAF_TYPE_DARK_OAK => Blocks::DARK_OAK_LEAVES(),
-			default => throw $in->badValueException(StateNames::NEW_LEAF_TYPE, $type),
-		}, $in));
+	private function registerSaplingDeserializers() : void{
+		foreach([
+			Ids::ACACIA_SAPLING => fn() => Blocks::ACACIA_SAPLING(),
+			Ids::BIRCH_SAPLING => fn() => Blocks::BIRCH_SAPLING(),
+			Ids::DARK_OAK_SAPLING => fn() => Blocks::DARK_OAK_SAPLING(),
+			Ids::JUNGLE_SAPLING => fn() => Blocks::JUNGLE_SAPLING(),
+			Ids::OAK_SAPLING => fn() => Blocks::OAK_SAPLING(),
+			Ids::SPRUCE_SAPLING => fn() => Blocks::SPRUCE_SAPLING(),
+		] as $id => $getBlock){
+			$this->map($id, fn(Reader $in) => Helper::decodeSapling($getBlock(), $in));
+		}
+	}
+
+	private function registerLightDeserializers() : void{
+		foreach([
+			Ids::LIGHT_BLOCK_0 => 0,
+			Ids::LIGHT_BLOCK_1 => 1,
+			Ids::LIGHT_BLOCK_2 => 2,
+			Ids::LIGHT_BLOCK_3 => 3,
+			Ids::LIGHT_BLOCK_4 => 4,
+			Ids::LIGHT_BLOCK_5 => 5,
+			Ids::LIGHT_BLOCK_6 => 6,
+			Ids::LIGHT_BLOCK_7 => 7,
+			Ids::LIGHT_BLOCK_8 => 8,
+			Ids::LIGHT_BLOCK_9 => 9,
+			Ids::LIGHT_BLOCK_10 => 10,
+			Ids::LIGHT_BLOCK_11 => 11,
+			Ids::LIGHT_BLOCK_12 => 12,
+			Ids::LIGHT_BLOCK_13 => 13,
+			Ids::LIGHT_BLOCK_14 => 14,
+			Ids::LIGHT_BLOCK_15 => 15,
+		] as $id => $level){
+			$this->mapSimple($id, fn() => Blocks::LIGHT()->setLightLevel($level));
+		}
 	}
 
 	private function registerSimpleDeserializers() : void{
 		$this->mapSimple(Ids::AIR, fn() => Blocks::AIR());
 		$this->mapSimple(Ids::AMETHYST_BLOCK, fn() => Blocks::AMETHYST());
 		$this->mapSimple(Ids::ANCIENT_DEBRIS, fn() => Blocks::ANCIENT_DEBRIS());
+		$this->mapSimple(Ids::ANDESITE, fn() => Blocks::ANDESITE());
 		$this->mapSimple(Ids::BARRIER, fn() => Blocks::BARRIER());
 		$this->mapSimple(Ids::BEACON, fn() => Blocks::BEACON());
 		$this->mapSimple(Ids::BLACKSTONE, fn() => Blocks::BLACKSTONE());
@@ -622,6 +709,9 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSimple(Ids::CHISELED_DEEPSLATE, fn() => Blocks::CHISELED_DEEPSLATE());
 		$this->mapSimple(Ids::CHISELED_NETHER_BRICKS, fn() => Blocks::CHISELED_NETHER_BRICKS());
 		$this->mapSimple(Ids::CHISELED_POLISHED_BLACKSTONE, fn() => Blocks::CHISELED_POLISHED_BLACKSTONE());
+		$this->mapSimple(Ids::CHISELED_RED_SANDSTONE, fn() => Blocks::CHISELED_RED_SANDSTONE());
+		$this->mapSimple(Ids::CHISELED_SANDSTONE, fn() => Blocks::CHISELED_SANDSTONE());
+		$this->mapSimple(Ids::CHISELED_STONE_BRICKS, fn() => Blocks::CHISELED_STONE_BRICKS());
 		$this->mapSimple(Ids::CHORUS_PLANT, fn() => Blocks::CHORUS_PLANT());
 		$this->mapSimple(Ids::CLAY, fn() => Blocks::CLAY());
 		$this->mapSimple(Ids::COAL_BLOCK, fn() => Blocks::COAL());
@@ -633,9 +723,13 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSimple(Ids::CRACKED_DEEPSLATE_TILES, fn() => Blocks::CRACKED_DEEPSLATE_TILES());
 		$this->mapSimple(Ids::CRACKED_NETHER_BRICKS, fn() => Blocks::CRACKED_NETHER_BRICKS());
 		$this->mapSimple(Ids::CRACKED_POLISHED_BLACKSTONE_BRICKS, fn() => Blocks::CRACKED_POLISHED_BLACKSTONE_BRICKS());
+		$this->mapSimple(Ids::CRACKED_STONE_BRICKS, fn() => Blocks::CRACKED_STONE_BRICKS());
 		$this->mapSimple(Ids::CRAFTING_TABLE, fn() => Blocks::CRAFTING_TABLE());
 		$this->mapSimple(Ids::CRIMSON_ROOTS, fn() => Blocks::CRIMSON_ROOTS());
 		$this->mapSimple(Ids::CRYING_OBSIDIAN, fn() => Blocks::CRYING_OBSIDIAN());
+		$this->mapSimple(Ids::CUT_RED_SANDSTONE, fn() => Blocks::CUT_RED_SANDSTONE());
+		$this->mapSimple(Ids::CUT_SANDSTONE, fn() => Blocks::CUT_SANDSTONE());
+		$this->mapSimple(Ids::DARK_PRISMARINE, fn() => Blocks::DARK_PRISMARINE());
 		$this->mapSimple(Ids::DEADBUSH, fn() => Blocks::DEAD_BUSH());
 		$this->mapSimple(Ids::DEEPSLATE_BRICKS, fn() => Blocks::DEEPSLATE_BRICKS());
 		$this->mapSimple(Ids::DEEPSLATE_COAL_ORE, fn() => Blocks::DEEPSLATE_COAL_ORE());
@@ -648,6 +742,7 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSimple(Ids::DEEPSLATE_TILES, fn() => Blocks::DEEPSLATE_TILES());
 		$this->mapSimple(Ids::DIAMOND_BLOCK, fn() => Blocks::DIAMOND());
 		$this->mapSimple(Ids::DIAMOND_ORE, fn() => Blocks::DIAMOND_ORE());
+		$this->mapSimple(Ids::DIORITE, fn() => Blocks::DIORITE());
 		$this->mapSimple(Ids::DRAGON_EGG, fn() => Blocks::DRAGON_EGG());
 		$this->mapSimple(Ids::DRIED_KELP_BLOCK, fn() => Blocks::DRIED_KELP());
 		$this->mapSimple(Ids::ELEMENT_0, fn() => Blocks::ELEMENT_ZERO());
@@ -774,6 +869,7 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSimple(Ids::ENCHANTING_TABLE, fn() => Blocks::ENCHANTING_TABLE());
 		$this->mapSimple(Ids::END_BRICKS, fn() => Blocks::END_STONE_BRICKS());
 		$this->mapSimple(Ids::END_STONE, fn() => Blocks::END_STONE());
+		$this->mapSimple(Ids::FERN, fn() => Blocks::FERN());
 		$this->mapSimple(Ids::FLETCHING_TABLE, fn() => Blocks::FLETCHING_TABLE());
 		$this->mapSimple(Ids::GILDED_BLACKSTONE, fn() => Blocks::GILDED_BLACKSTONE());
 		$this->mapSimple(Ids::GLASS, fn() => Blocks::GLASS());
@@ -782,7 +878,8 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSimple(Ids::GLOWSTONE, fn() => Blocks::GLOWSTONE());
 		$this->mapSimple(Ids::GOLD_BLOCK, fn() => Blocks::GOLD());
 		$this->mapSimple(Ids::GOLD_ORE, fn() => Blocks::GOLD_ORE());
-		$this->mapSimple(Ids::GRASS, fn() => Blocks::GRASS());
+		$this->mapSimple(Ids::GRANITE, fn() => Blocks::GRANITE());
+		$this->mapSimple(Ids::GRASS_BLOCK, fn() => Blocks::GRASS());
 		$this->mapSimple(Ids::GRASS_PATH, fn() => Blocks::GRASS_PATH());
 		$this->mapSimple(Ids::GRAVEL, fn() => Blocks::GRAVEL());
 		$this->mapSimple(Ids::HANGING_ROOTS, fn() => Blocks::HANGING_ROOTS());
@@ -791,6 +888,12 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSimple(Ids::HARDENED_CLAY, fn() => Blocks::HARDENED_CLAY());
 		$this->mapSimple(Ids::HONEYCOMB_BLOCK, fn() => Blocks::HONEYCOMB());
 		$this->mapSimple(Ids::ICE, fn() => Blocks::ICE());
+		$this->mapSimple(Ids::INFESTED_CHISELED_STONE_BRICKS, fn() => Blocks::INFESTED_CHISELED_STONE_BRICK());
+		$this->mapSimple(Ids::INFESTED_COBBLESTONE, fn() => Blocks::INFESTED_COBBLESTONE());
+		$this->mapSimple(Ids::INFESTED_CRACKED_STONE_BRICKS, fn() => Blocks::INFESTED_CRACKED_STONE_BRICK());
+		$this->mapSimple(Ids::INFESTED_MOSSY_STONE_BRICKS, fn() => Blocks::INFESTED_MOSSY_STONE_BRICK());
+		$this->mapSimple(Ids::INFESTED_STONE, fn() => Blocks::INFESTED_STONE());
+		$this->mapSimple(Ids::INFESTED_STONE_BRICKS, fn() => Blocks::INFESTED_STONE_BRICK());
 		$this->mapSimple(Ids::INFO_UPDATE, fn() => Blocks::INFO_UPDATE());
 		$this->mapSimple(Ids::INFO_UPDATE2, fn() => Blocks::INFO_UPDATE2());
 		$this->mapSimple(Ids::INVISIBLE_BEDROCK, fn() => Blocks::INVISIBLE_BEDROCK());
@@ -805,6 +908,7 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSimple(Ids::MELON_BLOCK, fn() => Blocks::MELON());
 		$this->mapSimple(Ids::MOB_SPAWNER, fn() => Blocks::MONSTER_SPAWNER());
 		$this->mapSimple(Ids::MOSSY_COBBLESTONE, fn() => Blocks::MOSSY_COBBLESTONE());
+		$this->mapSimple(Ids::MOSSY_STONE_BRICKS, fn() => Blocks::MOSSY_STONE_BRICKS());
 		$this->mapSimple(Ids::MUD, fn() => Blocks::MUD());
 		$this->mapSimple(Ids::MUD_BRICKS, fn() => Blocks::MUD_BRICKS());
 		$this->mapSimple(Ids::MYCELIUM, fn() => Blocks::MYCELIUM());
@@ -820,9 +924,14 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSimple(Ids::PACKED_ICE, fn() => Blocks::PACKED_ICE());
 		$this->mapSimple(Ids::PACKED_MUD, fn() => Blocks::PACKED_MUD());
 		$this->mapSimple(Ids::PODZOL, fn() => Blocks::PODZOL());
+		$this->mapSimple(Ids::POLISHED_ANDESITE, fn() => Blocks::POLISHED_ANDESITE());
 		$this->mapSimple(Ids::POLISHED_BLACKSTONE, fn() => Blocks::POLISHED_BLACKSTONE());
 		$this->mapSimple(Ids::POLISHED_BLACKSTONE_BRICKS, fn() => Blocks::POLISHED_BLACKSTONE_BRICKS());
 		$this->mapSimple(Ids::POLISHED_DEEPSLATE, fn() => Blocks::POLISHED_DEEPSLATE());
+		$this->mapSimple(Ids::POLISHED_DIORITE, fn() => Blocks::POLISHED_DIORITE());
+		$this->mapSimple(Ids::POLISHED_GRANITE, fn() => Blocks::POLISHED_GRANITE());
+		$this->mapSimple(Ids::PRISMARINE, fn() => Blocks::PRISMARINE());
+		$this->mapSimple(Ids::PRISMARINE_BRICKS, fn() => Blocks::PRISMARINE_BRICKS());
 		$this->mapSimple(Ids::QUARTZ_BRICKS, fn() => Blocks::QUARTZ_BRICKS());
 		$this->mapSimple(Ids::QUARTZ_ORE, fn() => Blocks::NETHER_QUARTZ_ORE());
 		$this->mapSimple(Ids::RAW_COPPER_BLOCK, fn() => Blocks::RAW_COPPER());
@@ -830,21 +939,30 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSimple(Ids::RAW_IRON_BLOCK, fn() => Blocks::RAW_IRON());
 		$this->mapSimple(Ids::RED_MUSHROOM, fn() => Blocks::RED_MUSHROOM());
 		$this->mapSimple(Ids::RED_NETHER_BRICK, fn() => Blocks::RED_NETHER_BRICKS());
+		$this->mapSimple(Ids::RED_SAND, fn() => Blocks::RED_SAND());
+		$this->mapSimple(Ids::RED_SANDSTONE, fn() => Blocks::RED_SANDSTONE());
 		$this->mapSimple(Ids::REDSTONE_BLOCK, fn() => Blocks::REDSTONE());
 		$this->mapSimple(Ids::REINFORCED_DEEPSLATE, fn() => Blocks::REINFORCED_DEEPSLATE());
 		$this->mapSimple(Ids::RESERVED6, fn() => Blocks::RESERVED6());
+		$this->mapSimple(Ids::SAND, fn() => Blocks::SAND());
+		$this->mapSimple(Ids::SANDSTONE, fn() => Blocks::SANDSTONE());
 		$this->mapSimple(Ids::SCULK, fn() => Blocks::SCULK());
 		$this->mapSimple(Ids::SEA_LANTERN, fn() => Blocks::SEA_LANTERN());
+		$this->mapSimple(Ids::SHORT_GRASS, fn() => Blocks::TALL_GRASS()); //no, this is not a typo - tall_grass is now the double block, just to be confusing :(
 		$this->mapSimple(Ids::SHROOMLIGHT, fn() => Blocks::SHROOMLIGHT());
 		$this->mapSimple(Ids::SLIME, fn() => Blocks::SLIME());
 		$this->mapSimple(Ids::SMITHING_TABLE, fn() => Blocks::SMITHING_TABLE());
 		$this->mapSimple(Ids::SMOOTH_BASALT, fn() => Blocks::SMOOTH_BASALT());
+		$this->mapSimple(Ids::SMOOTH_RED_SANDSTONE, fn() => Blocks::SMOOTH_RED_SANDSTONE());
+		$this->mapSimple(Ids::SMOOTH_SANDSTONE, fn() => Blocks::SMOOTH_SANDSTONE());
 		$this->mapSimple(Ids::SMOOTH_STONE, fn() => Blocks::SMOOTH_STONE());
 		$this->mapSimple(Ids::SNOW, fn() => Blocks::SNOW());
 		$this->mapSimple(Ids::SOUL_SAND, fn() => Blocks::SOUL_SAND());
 		$this->mapSimple(Ids::SOUL_SOIL, fn() => Blocks::SOUL_SOIL());
 		$this->mapSimple(Ids::SPORE_BLOSSOM, fn() => Blocks::SPORE_BLOSSOM());
+		$this->mapSimple(Ids::STONE, fn() => Blocks::STONE());
 		$this->mapSimple(Ids::STONECUTTER, fn() => Blocks::LEGACY_STONECUTTER());
+		$this->mapSimple(Ids::STONE_BRICKS, fn() => Blocks::STONE_BRICKS());
 		$this->mapSimple(Ids::TINTED_GLASS, fn() => Blocks::TINTED_GLASS());
 		$this->mapSimple(Ids::TORCHFLOWER, fn() => Blocks::TORCHFLOWER());
 		$this->mapSimple(Ids::TUFF, fn() => Blocks::TUFF());
@@ -854,7 +972,19 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSimple(Ids::WATERLILY, fn() => Blocks::LILY_PAD());
 		$this->mapSimple(Ids::WEB, fn() => Blocks::COBWEB());
 		$this->mapSimple(Ids::WITHER_ROSE, fn() => Blocks::WITHER_ROSE());
-		$this->mapSimple(Ids::YELLOW_FLOWER, fn() => Blocks::DANDELION());
+		$this->mapSimple(Ids::DANDELION, fn() => Blocks::DANDELION());
+
+		$this->mapSimple(Ids::ALLIUM, fn() => Blocks::ALLIUM());
+		$this->mapSimple(Ids::CORNFLOWER, fn() => Blocks::CORNFLOWER());
+		$this->mapSimple(Ids::AZURE_BLUET, fn() => Blocks::AZURE_BLUET());
+		$this->mapSimple(Ids::LILY_OF_THE_VALLEY, fn() => Blocks::LILY_OF_THE_VALLEY());
+		$this->mapSimple(Ids::BLUE_ORCHID, fn() => Blocks::BLUE_ORCHID());
+		$this->mapSimple(Ids::OXEYE_DAISY, fn() => Blocks::OXEYE_DAISY());
+		$this->mapSimple(Ids::POPPY, fn() => Blocks::POPPY());
+		$this->mapSimple(Ids::ORANGE_TULIP, fn() => Blocks::ORANGE_TULIP());
+		$this->mapSimple(Ids::PINK_TULIP, fn() => Blocks::PINK_TULIP());
+		$this->mapSimple(Ids::RED_TULIP, fn() => Blocks::RED_TULIP());
+		$this->mapSimple(Ids::WHITE_TULIP, fn() => Blocks::WHITE_TULIP());
 	}
 
 	private function registerDeserializers() : void{
@@ -868,16 +998,21 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 				->setStage(AmethystCluster::STAGE_CLUSTER)
 				->setFacing($in->readBlockFace());
 		});
+		$this->mapSlab(Ids::ANDESITE_SLAB, Ids::ANDESITE_DOUBLE_SLAB, fn() => Blocks::ANDESITE_SLAB());
 		$this->mapStairs(Ids::ANDESITE_STAIRS, fn() => Blocks::ANDESITE_STAIRS());
 		$this->map(Ids::ANVIL, function(Reader $in) : Block{
 			return Blocks::ANVIL()
-				->setDamage(match($value = $in->readString(StateNames::DAMAGE)){
-					StringValues::DAMAGE_UNDAMAGED => 0,
-					StringValues::DAMAGE_SLIGHTLY_DAMAGED => 1,
-					StringValues::DAMAGE_VERY_DAMAGED => 2,
-					StringValues::DAMAGE_BROKEN => 0,
-					default => throw $in->badValueException(StateNames::DAMAGE, $value),
-				})
+				->setDamage(Anvil::UNDAMAGED)
+				->setFacing($in->readCardinalHorizontalFacing());
+		});
+		$this->map(Ids::CHIPPED_ANVIL, function(Reader $in) : Block{
+			return Blocks::ANVIL()
+				->setDamage(Anvil::SLIGHTLY_DAMAGED)
+				->setFacing($in->readCardinalHorizontalFacing());
+		});
+		$this->map(Ids::DAMAGED_ANVIL, function(Reader $in) : Block{
+			return Blocks::ANVIL()
+				->setDamage(Anvil::VERY_DAMAGED)
 				->setFacing($in->readCardinalHorizontalFacing());
 		});
 		$this->map(Ids::BAMBOO, function(Reader $in) : Block{
@@ -896,7 +1031,6 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 				});
 		});
 		$this->map(Ids::BAMBOO_SAPLING, function(Reader $in) : Block{
-			$in->ignored(StateNames::SAPLING_TYPE); //bug in MCPE
 			return Blocks::BAMBOO_SAPLING()->setReady($in->readBool(StateNames::AGE_BIT));
 		});
 		$this->map(Ids::BARREL, function(Reader $in) : Block{
@@ -959,6 +1093,7 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 				->setSlot(BrewingStandSlot::SOUTHWEST, $in->readBool(StateNames::BREWING_STAND_SLOT_B_BIT))
 				->setSlot(BrewingStandSlot::NORTHWEST, $in->readBool(StateNames::BREWING_STAND_SLOT_C_BIT));
 		});
+		$this->mapSlab(Ids::BRICK_SLAB, Ids::BRICK_DOUBLE_SLAB, fn() => Blocks::BRICK_SLAB());
 		$this->mapStairs(Ids::BRICK_STAIRS, fn() => Blocks::BRICK_STAIRS());
 		$this->map(Ids::BROWN_MUSHROOM_BLOCK, fn(Reader $in) => Helper::decodeMushroomBlock(Blocks::BROWN_MUSHROOM_BLOCK(), $in));
 		$this->map(Ids::CACTUS, function(Reader $in) : Block{
@@ -1008,6 +1143,10 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 
 			return $block;
 		});
+		$this->map(Ids::CHISELED_QUARTZ_BLOCK, function(Reader $in) : Block{
+			return Blocks::CHISELED_QUARTZ()
+				->setAxis($in->readPillarAxis());
+		});
 		$this->map(Ids::CHEMISTRY_TABLE, function(Reader $in) : Block{
 			return (match($type = $in->readString(StateNames::CHEMISTRY_TABLE_TYPE)){
 				StringValues::CHEMISTRY_TABLE_TYPE_COMPOUND_CREATOR => Blocks::COMPOUND_CREATOR(),
@@ -1025,9 +1164,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 			return Blocks::CHORUS_FLOWER()
 				->setAge($in->readBoundedInt(StateNames::AGE, ChorusFlower::MIN_AGE, ChorusFlower::MAX_AGE));
 		});
+		$this->map(Ids::COARSE_DIRT, fn() => Blocks::DIRT()->setDirtType(DirtType::COARSE));
 		$this->mapSlab(Ids::COBBLED_DEEPSLATE_SLAB, Ids::COBBLED_DEEPSLATE_DOUBLE_SLAB, fn() => Blocks::COBBLED_DEEPSLATE_SLAB());
 		$this->mapStairs(Ids::COBBLED_DEEPSLATE_STAIRS, fn() => Blocks::COBBLED_DEEPSLATE_STAIRS());
 		$this->map(Ids::COBBLED_DEEPSLATE_WALL, fn(Reader $in) => Helper::decodeWall(Blocks::COBBLED_DEEPSLATE_WALL(), $in));
+		$this->mapSlab(Ids::COBBLESTONE_SLAB, Ids::COBBLESTONE_DOUBLE_SLAB, fn() => Blocks::COBBLESTONE_SLAB());
 		$this->map(Ids::COBBLESTONE_WALL, fn(Reader $in) => Helper::mapLegacyWallType($in));
 		$this->map(Ids::COCOA, function(Reader $in) : Block{
 			return Blocks::COCOA_POD()
@@ -1048,24 +1189,9 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->map(Ids::CUT_COPPER, fn() => Helper::decodeCopper(Blocks::CUT_COPPER(), CopperOxidation::NONE));
 		$this->mapSlab(Ids::CUT_COPPER_SLAB, Ids::DOUBLE_CUT_COPPER_SLAB, fn() => Helper::decodeCopper(Blocks::CUT_COPPER_SLAB(), CopperOxidation::NONE));
 		$this->mapStairs(Ids::CUT_COPPER_STAIRS, fn() => Helper::decodeCopper(Blocks::CUT_COPPER_STAIRS(), CopperOxidation::NONE));
-		$this->map(Ids::CORAL_BLOCK, function(Reader $in) : Block{
-			return Blocks::CORAL_BLOCK()
-				->setCoralType($in->readCoralType())
-				->setDead($in->readBool(StateNames::DEAD_BIT));
-		});
-		$this->map(Ids::CORAL_FAN, fn(Reader $in) => Helper::decodeFloorCoralFan(Blocks::CORAL_FAN(), $in)
-				->setDead(false));
-		$this->map(Ids::CORAL_FAN_DEAD, fn(Reader $in) => Helper::decodeFloorCoralFan(Blocks::CORAL_FAN(), $in)
-				->setDead(true));
-		$this->map(Ids::CORAL_FAN_HANG, fn(Reader $in) => Helper::decodeWallCoralFan(Blocks::WALL_CORAL_FAN(), $in)
-				->setCoralType($in->readBool(StateNames::CORAL_HANG_TYPE_BIT) ? CoralType::BRAIN : CoralType::TUBE));
-		$this->map(Ids::CORAL_FAN_HANG2, fn(Reader $in) => Helper::decodeWallCoralFan(Blocks::WALL_CORAL_FAN(), $in)
-				->setCoralType($in->readBool(StateNames::CORAL_HANG_TYPE_BIT) ? CoralType::FIRE : CoralType::BUBBLE));
-		$this->map(Ids::CORAL_FAN_HANG3, function(Reader $in) : Block{
-			$in->ignored(StateNames::CORAL_HANG_TYPE_BIT); //the game always writes this, even though it's not used
-			return Helper::decodeWallCoralFan(Blocks::WALL_CORAL_FAN(), $in)
-				->setCoralType(CoralType::HORN);
-		});
+		$this->mapSlab(Ids::CUT_RED_SANDSTONE_SLAB, Ids::CUT_RED_SANDSTONE_DOUBLE_SLAB, fn() => Blocks::CUT_RED_SANDSTONE_SLAB());
+		$this->mapSlab(Ids::CUT_SANDSTONE_SLAB, Ids::CUT_SANDSTONE_DOUBLE_SLAB, fn() => Blocks::CUT_SANDSTONE_SLAB());
+		$this->mapSlab(Ids::DARK_PRISMARINE_SLAB, Ids::DARK_PRISMARINE_DOUBLE_SLAB, fn() => Blocks::DARK_PRISMARINE_SLAB());
 		$this->mapStairs(Ids::DARK_PRISMARINE_STAIRS, fn() => Blocks::DARK_PRISMARINE_STAIRS());
 		$this->map(Ids::DAYLIGHT_DETECTOR, fn(Reader $in) => Helper::decodeDaylightSensor(Blocks::DAYLIGHT_SENSOR(), $in)
 				->setInverted(false));
@@ -1087,27 +1213,16 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 				->setActivated($in->readBool(StateNames::RAIL_DATA_BIT))
 				->setShape($in->readBoundedInt(StateNames::RAIL_DIRECTION, 0, 5));
 		});
+		$this->mapSlab(Ids::DIORITE_SLAB, Ids::DIORITE_DOUBLE_SLAB, fn() => Blocks::DIORITE_SLAB());
 		$this->mapStairs(Ids::DIORITE_STAIRS, fn() => Blocks::DIORITE_STAIRS());
-		$this->map(Ids::DIRT, function(Reader $in) : Block{
-			return Blocks::DIRT()
-				->setDirtType(match($value = $in->readString(StateNames::DIRT_TYPE)){
-					StringValues::DIRT_TYPE_NORMAL => DirtType::NORMAL,
-					StringValues::DIRT_TYPE_COARSE => DirtType::COARSE,
-					default => throw $in->badValueException(StateNames::DIRT_TYPE, $value),
-				});
-		});
+		$this->map(Ids::DIRT, fn() => Blocks::DIRT()->setDirtType(DirtType::NORMAL));
 		$this->map(Ids::DIRT_WITH_ROOTS, fn() => Blocks::DIRT()->setDirtType(DirtType::ROOTED));
-		$this->map(Ids::DOUBLE_PLANT, function(Reader $in) : Block{
-			return (match($type = $in->readString(StateNames::DOUBLE_PLANT_TYPE)){
-				StringValues::DOUBLE_PLANT_TYPE_FERN => Blocks::LARGE_FERN(),
-				StringValues::DOUBLE_PLANT_TYPE_GRASS => Blocks::DOUBLE_TALLGRASS(),
-				StringValues::DOUBLE_PLANT_TYPE_PAEONIA => Blocks::PEONY(),
-				StringValues::DOUBLE_PLANT_TYPE_ROSE => Blocks::ROSE_BUSH(),
-				StringValues::DOUBLE_PLANT_TYPE_SUNFLOWER => Blocks::SUNFLOWER(),
-				StringValues::DOUBLE_PLANT_TYPE_SYRINGA => Blocks::LILAC(),
-				default => throw $in->badValueException(StateNames::DOUBLE_PLANT_TYPE, $type),
-			})->setTop($in->readBool(StateNames::UPPER_BLOCK_BIT));
-		});
+		$this->map(Ids::LARGE_FERN, fn(Reader $in) => Helper::decodeDoublePlant(Blocks::LARGE_FERN(), $in));
+		$this->map(Ids::TALL_GRASS, fn(Reader $in) => Helper::decodeDoublePlant(Blocks::DOUBLE_TALLGRASS(), $in));
+		$this->map(Ids::PEONY, fn(Reader $in) => Helper::decodeDoublePlant(Blocks::PEONY(), $in));
+		$this->map(Ids::ROSE_BUSH, fn(Reader $in) => Helper::decodeDoublePlant(Blocks::ROSE_BUSH(), $in));
+		$this->map(Ids::SUNFLOWER, fn(Reader $in) => Helper::decodeDoublePlant(Blocks::SUNFLOWER(), $in));
+		$this->map(Ids::LILAC, fn(Reader $in) => Helper::decodeDoublePlant(Blocks::LILAC(), $in));
 		$this->mapStairs(Ids::END_BRICK_STAIRS, fn() => Blocks::END_STONE_BRICK_STAIRS());
 		$this->map(Ids::END_PORTAL_FRAME, function(Reader $in) : Block{
 			return Blocks::END_PORTAL_FRAME()
@@ -1118,6 +1233,7 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 			return Blocks::END_ROD()
 				->setFacing($in->readEndRodFacingDirection());
 		});
+		$this->mapSlab(Ids::END_STONE_BRICK_SLAB, Ids::END_STONE_BRICK_DOUBLE_SLAB, fn() => Blocks::END_STONE_BRICK_SLAB());
 		$this->map(Ids::ENDER_CHEST, function(Reader $in) : Block{
 			return Blocks::ENDER_CHEST()
 				->setFacing($in->readCardinalHorizontalFacing());
@@ -1157,15 +1273,8 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 				->setPowered($in->readBool(StateNames::RAIL_DATA_BIT))
 				->setShape($in->readBoundedInt(StateNames::RAIL_DIRECTION, 0, 5));
 		});
+		$this->mapSlab(Ids::GRANITE_SLAB, Ids::GRANITE_DOUBLE_SLAB, fn() => Blocks::GRANITE_SLAB());
 		$this->mapStairs(Ids::GRANITE_STAIRS, fn() => Blocks::GRANITE_STAIRS());
-		$this->map(Ids::HARD_STAINED_GLASS, function(Reader $in) : Block{
-			return Blocks::STAINED_HARDENED_GLASS()
-				->setColor($in->readColor());
-		});
-		$this->map(Ids::HARD_STAINED_GLASS_PANE, function(Reader $in) : Block{
-			return Blocks::STAINED_HARDENED_GLASS_PANE()
-				->setColor($in->readColor());
-		});
 		$this->map(Ids::HAY_BLOCK, function(Reader $in) : Block{
 			$in->ignored(StateNames::DEPRECATED);
 			return Blocks::HAY_BALE()->setAxis($in->readPillarAxis());
@@ -1212,10 +1321,6 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 					default => throw $in->badValueException(StateNames::LEVER_DIRECTION, $value),
 				});
 		});
-		$this->map(Ids::LIGHT_BLOCK, function(Reader $in) : Block{
-			return Blocks::LIGHT()
-				->setLightLevel($in->readBoundedInt(StateNames::BLOCK_LIGHT_LEVEL, Light::MIN_LIGHT_LEVEL, Light::MAX_LIGHT_LEVEL));
-		});
 		$this->map(Ids::LIGHTNING_ROD, function(Reader $in) : Block{
 			return Blocks::LIGHTNING_ROD()
 				->setFacing($in->readFacingDirection());
@@ -1259,18 +1364,9 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 				->setFacing($in->readBlockFace());
 		});
 		$this->map(Ids::MELON_STEM, fn(Reader $in) => Helper::decodeStem(Blocks::MELON_STEM(), $in));
-		$this->map(Ids::MONSTER_EGG, function(Reader $in) : Block{
-			return match($type = $in->readString(StateNames::MONSTER_EGG_STONE_TYPE)){
-				StringValues::MONSTER_EGG_STONE_TYPE_CHISELED_STONE_BRICK => Blocks::INFESTED_CHISELED_STONE_BRICK(),
-				StringValues::MONSTER_EGG_STONE_TYPE_COBBLESTONE => Blocks::INFESTED_COBBLESTONE(),
-				StringValues::MONSTER_EGG_STONE_TYPE_CRACKED_STONE_BRICK => Blocks::INFESTED_CRACKED_STONE_BRICK(),
-				StringValues::MONSTER_EGG_STONE_TYPE_MOSSY_STONE_BRICK => Blocks::INFESTED_MOSSY_STONE_BRICK(),
-				StringValues::MONSTER_EGG_STONE_TYPE_STONE => Blocks::INFESTED_STONE(),
-				StringValues::MONSTER_EGG_STONE_TYPE_STONE_BRICK => Blocks::INFESTED_STONE_BRICK(),
-				default => throw $in->badValueException(StateNames::MONSTER_EGG_STONE_TYPE, $type),
-			};
-		});
+		$this->mapSlab(Ids::MOSSY_COBBLESTONE_SLAB, Ids::MOSSY_COBBLESTONE_DOUBLE_SLAB, fn() => Blocks::MOSSY_COBBLESTONE_SLAB());
 		$this->mapStairs(Ids::MOSSY_COBBLESTONE_STAIRS, fn() => Blocks::MOSSY_COBBLESTONE_STAIRS());
+		$this->mapSlab(Ids::MOSSY_STONE_BRICK_SLAB, Ids::MOSSY_STONE_BRICK_DOUBLE_SLAB, fn() => Blocks::MOSSY_STONE_BRICK_SLAB());
 		$this->mapStairs(Ids::MOSSY_STONE_BRICK_STAIRS, fn() => Blocks::MOSSY_STONE_BRICK_STAIRS());
 		$this->mapSlab(Ids::MUD_BRICK_SLAB, Ids::MUD_BRICK_DOUBLE_SLAB, fn() => Blocks::MUD_BRICK_SLAB());
 		$this->mapStairs(Ids::MUD_BRICK_STAIRS, fn() => Blocks::MUD_BRICK_STAIRS());
@@ -1279,11 +1375,13 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 			return Blocks::MUDDY_MANGROVE_ROOTS()
 				->setAxis($in->readPillarAxis());
 		});
+		$this->mapSlab(Ids::NETHER_BRICK_SLAB, Ids::NETHER_BRICK_DOUBLE_SLAB, fn() => Blocks::NETHER_BRICK_SLAB());
 		$this->mapStairs(Ids::NETHER_BRICK_STAIRS, fn() => Blocks::NETHER_BRICK_STAIRS());
 		$this->map(Ids::NETHER_WART, function(Reader $in) : Block{
 			return Blocks::NETHER_WART()
 				->setAge($in->readBoundedInt(StateNames::AGE, 0, 3));
 		});
+		$this->mapSlab(Ids::NORMAL_STONE_SLAB, Ids::NORMAL_STONE_DOUBLE_SLAB, fn() => Blocks::STONE_SLAB());
 		$this->mapStairs(Ids::NORMAL_STONE_STAIRS, fn() => Blocks::STONE_STAIRS());
 		$this->map(Ids::OCHRE_FROGLIGHT, fn(Reader $in) => Blocks::FROGLIGHT()->setFroglightType(FroglightType::OCHRE)->setAxis($in->readPillarAxis()));
 		$this->map(Ids::OXIDIZED_COPPER, fn() => Helper::decodeCopper(Blocks::COPPER(), CopperOxidation::OXIDIZED));
@@ -1291,6 +1389,7 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSlab(Ids::OXIDIZED_CUT_COPPER_SLAB, Ids::OXIDIZED_DOUBLE_CUT_COPPER_SLAB, fn() => Helper::decodeCopper(Blocks::CUT_COPPER_SLAB(), CopperOxidation::OXIDIZED));
 		$this->mapStairs(Ids::OXIDIZED_CUT_COPPER_STAIRS, fn() => Helper::decodeCopper(Blocks::CUT_COPPER_STAIRS(), CopperOxidation::OXIDIZED));
 		$this->map(Ids::PEARLESCENT_FROGLIGHT, fn(Reader $in) => Blocks::FROGLIGHT()->setFroglightType(FroglightType::PEARLESCENT)->setAxis($in->readPillarAxis()));
+		$this->mapSlab(Ids::PETRIFIED_OAK_SLAB, Ids::PETRIFIED_OAK_DOUBLE_SLAB, fn() => Blocks::FAKE_WOODEN_SLAB());
 		$this->map(Ids::PINK_PETALS, function(Reader $in) : Block{
 			//Pink petals only uses 0-3, but GROWTH state can go up to 7
 			$growth = $in->readBoundedInt(StateNames::GROWTH, 0, 7);
@@ -1314,6 +1413,7 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 			return Blocks::PITCHER_PLANT()
 				->setTop($in->readBool(StateNames::UPPER_BLOCK_BIT));
 		});
+		$this->mapSlab(Ids::POLISHED_ANDESITE_SLAB, Ids::POLISHED_ANDESITE_DOUBLE_SLAB, fn() => Blocks::POLISHED_ANDESITE_SLAB());
 		$this->mapStairs(Ids::POLISHED_ANDESITE_STAIRS, fn() => Blocks::POLISHED_ANDESITE_STAIRS());
 		$this->map(Ids::POLISHED_BASALT, function(Reader $in) : Block{
 			return Blocks::POLISHED_BASALT()
@@ -1330,7 +1430,9 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->mapSlab(Ids::POLISHED_DEEPSLATE_SLAB, Ids::POLISHED_DEEPSLATE_DOUBLE_SLAB, fn() => Blocks::POLISHED_DEEPSLATE_SLAB());
 		$this->mapStairs(Ids::POLISHED_DEEPSLATE_STAIRS, fn() => Blocks::POLISHED_DEEPSLATE_STAIRS());
 		$this->map(Ids::POLISHED_DEEPSLATE_WALL, fn(Reader $in) => Helper::decodeWall(Blocks::POLISHED_DEEPSLATE_WALL(), $in));
+		$this->mapSlab(Ids::POLISHED_DIORITE_SLAB, Ids::POLISHED_DIORITE_DOUBLE_SLAB, fn() => Blocks::POLISHED_DIORITE_SLAB());
 		$this->mapStairs(Ids::POLISHED_DIORITE_STAIRS, fn() => Blocks::POLISHED_DIORITE_STAIRS());
+		$this->mapSlab(Ids::POLISHED_GRANITE_SLAB, Ids::POLISHED_GRANITE_DOUBLE_SLAB, fn() => Blocks::POLISHED_GRANITE_SLAB());
 		$this->mapStairs(Ids::POLISHED_GRANITE_STAIRS, fn() => Blocks::POLISHED_GRANITE_STAIRS());
 		$this->map(Ids::PORTAL, function(Reader $in) : Block{
 			return Blocks::NETHER_PORTAL()
@@ -1345,15 +1447,9 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 		$this->map(Ids::POWERED_COMPARATOR, fn(Reader $in) => Helper::decodeComparator(Blocks::REDSTONE_COMPARATOR(), $in));
 		$this->map(Ids::POWERED_REPEATER, fn(Reader $in) => Helper::decodeRepeater(Blocks::REDSTONE_REPEATER(), $in)
 				->setPowered(true));
-		$this->map(Ids::PRISMARINE, function(Reader $in) : Block{
-			return match($type = $in->readString(StateNames::PRISMARINE_BLOCK_TYPE)){
-				StringValues::PRISMARINE_BLOCK_TYPE_BRICKS => Blocks::PRISMARINE_BRICKS(),
-				StringValues::PRISMARINE_BLOCK_TYPE_DARK => Blocks::DARK_PRISMARINE(),
-				StringValues::PRISMARINE_BLOCK_TYPE_DEFAULT => Blocks::PRISMARINE(),
-				default => throw $in->badValueException(StateNames::PRISMARINE_BLOCK_TYPE, $type),
-			};
-		});
+		$this->mapSlab(Ids::PRISMARINE_BRICK_SLAB, Ids::PRISMARINE_BRICK_DOUBLE_SLAB, fn() => Blocks::PRISMARINE_BRICKS_SLAB());
 		$this->mapStairs(Ids::PRISMARINE_BRICKS_STAIRS, fn() => Blocks::PRISMARINE_BRICKS_STAIRS());
+		$this->mapSlab(Ids::PRISMARINE_SLAB, Ids::PRISMARINE_DOUBLE_SLAB, fn() => Blocks::PRISMARINE_SLAB());
 		$this->mapStairs(Ids::PRISMARINE_STAIRS, fn() => Blocks::PRISMARINE_STAIRS());
 		$this->map(Ids::PUMPKIN, function(Reader $in) : Block{
 			$in->ignored(StateNames::MC_CARDINAL_DIRECTION); //obsolete
@@ -1374,55 +1470,26 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 				};
 			}
 		});
+		$this->mapSlab(Ids::PURPUR_SLAB, Ids::PURPUR_DOUBLE_SLAB, fn() => Blocks::PURPUR_SLAB());
 		$this->mapStairs(Ids::PURPUR_STAIRS, fn() => Blocks::PURPUR_STAIRS());
-		$this->map(Ids::QUARTZ_BLOCK, function(Reader $in) : Block{
-			switch($type = $in->readString(StateNames::CHISEL_TYPE)){
-				case StringValues::CHISEL_TYPE_CHISELED:
-					return Blocks::CHISELED_QUARTZ()->setAxis($in->readPillarAxis());
-				case StringValues::CHISEL_TYPE_DEFAULT:
-					$in->ignored(StateNames::PILLAR_AXIS);
-					return Blocks::QUARTZ();
-				case StringValues::CHISEL_TYPE_LINES:
-					return Blocks::QUARTZ_PILLAR()->setAxis($in->readPillarAxis());
-				case StringValues::CHISEL_TYPE_SMOOTH:
-					$in->ignored(StateNames::PILLAR_AXIS);
-					return Blocks::SMOOTH_QUARTZ();
-				default:
-					return throw $in->badValueException(StateNames::CHISEL_TYPE, $type);
-			}
+		$this->map(Ids::QUARTZ_BLOCK, function(Reader $in) : Opaque{
+			$in->ignored(StateNames::PILLAR_AXIS);
+			return Blocks::QUARTZ();
 		});
+		$this->map(Ids::QUARTZ_PILLAR, function(Reader $in) : Block{
+			return Blocks::QUARTZ_PILLAR()
+				->setAxis($in->readPillarAxis());
+		});
+		$this->mapSlab(Ids::QUARTZ_SLAB, Ids::QUARTZ_DOUBLE_SLAB, fn() => Blocks::QUARTZ_SLAB());
 		$this->mapStairs(Ids::QUARTZ_STAIRS, fn() => Blocks::QUARTZ_STAIRS());
 		$this->map(Ids::RAIL, function(Reader $in) : Block{
 			return Blocks::RAIL()
 				->setShape($in->readBoundedInt(StateNames::RAIL_DIRECTION, 0, 9));
 		});
-		$this->map(Ids::RED_FLOWER, function(Reader $in) : Block{
-			return match($type = $in->readString(StateNames::FLOWER_TYPE)){
-				StringValues::FLOWER_TYPE_ALLIUM => Blocks::ALLIUM(),
-				StringValues::FLOWER_TYPE_CORNFLOWER => Blocks::CORNFLOWER(),
-				StringValues::FLOWER_TYPE_HOUSTONIA => Blocks::AZURE_BLUET(), //wtf ???
-				StringValues::FLOWER_TYPE_LILY_OF_THE_VALLEY => Blocks::LILY_OF_THE_VALLEY(),
-				StringValues::FLOWER_TYPE_ORCHID => Blocks::BLUE_ORCHID(),
-				StringValues::FLOWER_TYPE_OXEYE => Blocks::OXEYE_DAISY(),
-				StringValues::FLOWER_TYPE_POPPY => Blocks::POPPY(),
-				StringValues::FLOWER_TYPE_TULIP_ORANGE => Blocks::ORANGE_TULIP(),
-				StringValues::FLOWER_TYPE_TULIP_PINK => Blocks::PINK_TULIP(),
-				StringValues::FLOWER_TYPE_TULIP_RED => Blocks::RED_TULIP(),
-				StringValues::FLOWER_TYPE_TULIP_WHITE => Blocks::WHITE_TULIP(),
-				default => throw $in->badValueException(StateNames::FLOWER_TYPE, $type),
-			};
-		});
 		$this->map(Ids::RED_MUSHROOM_BLOCK, fn(Reader $in) => Helper::decodeMushroomBlock(Blocks::RED_MUSHROOM_BLOCK(), $in));
+		$this->mapSlab(Ids::RED_NETHER_BRICK_SLAB, Ids::RED_NETHER_BRICK_DOUBLE_SLAB, fn() => Blocks::RED_NETHER_BRICK_SLAB());
 		$this->mapStairs(Ids::RED_NETHER_BRICK_STAIRS, fn() => Blocks::RED_NETHER_BRICK_STAIRS());
-		$this->map(Ids::RED_SANDSTONE, function(Reader $in) : Block{
-			return match($type = $in->readString(StateNames::SAND_STONE_TYPE)){
-				StringValues::SAND_STONE_TYPE_CUT => Blocks::CUT_RED_SANDSTONE(),
-				StringValues::SAND_STONE_TYPE_DEFAULT => Blocks::RED_SANDSTONE(),
-				StringValues::SAND_STONE_TYPE_HEIROGLYPHS => Blocks::CHISELED_RED_SANDSTONE(),
-				StringValues::SAND_STONE_TYPE_SMOOTH => Blocks::SMOOTH_RED_SANDSTONE(),
-				default => throw $in->badValueException(StateNames::SAND_STONE_TYPE, $type),
-			};
-		});
+		$this->mapSlab(Ids::RED_SANDSTONE_SLAB, Ids::RED_SANDSTONE_DOUBLE_SLAB, fn() => Blocks::RED_SANDSTONE_SLAB());
 		$this->mapStairs(Ids::RED_SANDSTONE_STAIRS, fn() => Blocks::RED_SANDSTONE_STAIRS());
 		$this->map(Ids::REDSTONE_LAMP, function() : Block{
 			return Blocks::REDSTONE_LAMP()
@@ -1445,35 +1512,8 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 			return Blocks::SUGARCANE()
 				->setAge($in->readBoundedInt(StateNames::AGE, 0, 15));
 		});
-		$this->map(Ids::SAND, function(Reader $in) : Block{
-			return match($value = $in->readString(StateNames::SAND_TYPE)){
-				StringValues::SAND_TYPE_NORMAL => Blocks::SAND(),
-				StringValues::SAND_TYPE_RED => Blocks::RED_SAND(),
-				default => throw $in->badValueException(StateNames::SAND_TYPE, $value),
-			};
-		});
-		$this->map(Ids::SANDSTONE, function(Reader $in) : Block{
-			return match($type = $in->readString(StateNames::SAND_STONE_TYPE)){
-				StringValues::SAND_STONE_TYPE_CUT => Blocks::CUT_SANDSTONE(),
-				StringValues::SAND_STONE_TYPE_DEFAULT => Blocks::SANDSTONE(),
-				StringValues::SAND_STONE_TYPE_HEIROGLYPHS => Blocks::CHISELED_SANDSTONE(),
-				StringValues::SAND_STONE_TYPE_SMOOTH => Blocks::SMOOTH_SANDSTONE(),
-				default => throw $in->badValueException(StateNames::SAND_STONE_TYPE, $type),
-			};
-		});
+		$this->mapSlab(Ids::SANDSTONE_SLAB, Ids::SANDSTONE_DOUBLE_SLAB, fn() => Blocks::SANDSTONE_SLAB());
 		$this->mapStairs(Ids::SANDSTONE_STAIRS, fn() => Blocks::SANDSTONE_STAIRS());
-		$this->map(Ids::SAPLING, function(Reader $in) : Block{
-			return (match($type = $in->readString(StateNames::SAPLING_TYPE)){
-					StringValues::SAPLING_TYPE_ACACIA => Blocks::ACACIA_SAPLING(),
-					StringValues::SAPLING_TYPE_BIRCH => Blocks::BIRCH_SAPLING(),
-					StringValues::SAPLING_TYPE_DARK_OAK => Blocks::DARK_OAK_SAPLING(),
-					StringValues::SAPLING_TYPE_JUNGLE => Blocks::JUNGLE_SAPLING(),
-					StringValues::SAPLING_TYPE_OAK => Blocks::OAK_SAPLING(),
-					StringValues::SAPLING_TYPE_SPRUCE => Blocks::SPRUCE_SAPLING(),
-					default => throw $in->badValueException(StateNames::SAPLING_TYPE, $type),
-				})
-				->setReady($in->readBool(StateNames::AGE_BIT));
-		});
 		$this->map(Ids::SEA_PICKLE, function(Reader $in) : Block{
 			return Blocks::SEA_PICKLE()
 				->setCount($in->readBoundedInt(StateNames::CLUSTER_COUNT, 0, 3) + 1)
@@ -1498,9 +1538,17 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 				->setFacing($in->readCardinalHorizontalFacing())
 				->setTop($in->readBool(StateNames::UPPER_BLOCK_BIT));
 		});
+		$this->map(Ids::SMOOTH_QUARTZ, function(Reader $in) : Block{
+			$in->ignored(StateNames::PILLAR_AXIS);
+			return Blocks::SMOOTH_QUARTZ();
+		});
+		$this->mapSlab(Ids::SMOOTH_QUARTZ_SLAB, Ids::SMOOTH_QUARTZ_DOUBLE_SLAB, fn() => Blocks::SMOOTH_QUARTZ_SLAB());
 		$this->mapStairs(Ids::SMOOTH_QUARTZ_STAIRS, fn() => Blocks::SMOOTH_QUARTZ_STAIRS());
+		$this->mapSlab(Ids::SMOOTH_RED_SANDSTONE_SLAB, Ids::SMOOTH_RED_SANDSTONE_DOUBLE_SLAB, fn() => Blocks::SMOOTH_RED_SANDSTONE_SLAB());
 		$this->mapStairs(Ids::SMOOTH_RED_SANDSTONE_STAIRS, fn() => Blocks::SMOOTH_RED_SANDSTONE_STAIRS());
+		$this->mapSlab(Ids::SMOOTH_SANDSTONE_SLAB, Ids::SMOOTH_SANDSTONE_DOUBLE_SLAB, fn() => Blocks::SMOOTH_SANDSTONE_SLAB());
 		$this->mapStairs(Ids::SMOOTH_SANDSTONE_STAIRS, fn() => Blocks::SMOOTH_SANDSTONE_STAIRS());
+		$this->mapSlab(Ids::SMOOTH_STONE_SLAB, Ids::SMOOTH_STONE_DOUBLE_SLAB, fn() => Blocks::SMOOTH_STONE_SLAB());
 		$this->map(Ids::SNOW_LAYER, function(Reader $in) : Block{
 			$in->ignored(StateNames::COVERED_BIT); //seems to be useless
 			return Blocks::SNOW_LAYER()->setLayers($in->readBoundedInt(StateNames::HEIGHT, 0, 7) + 1);
@@ -1528,36 +1576,11 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 			return Blocks::BANNER()
 				->setRotation($in->readBoundedInt(StateNames::GROUND_SIGN_DIRECTION, 0, 15));
 		});
-		$this->map(Ids::STONE, function(Reader $in) : Block{
-			return match($type = $in->readString(StateNames::STONE_TYPE)){
-				StringValues::STONE_TYPE_ANDESITE => Blocks::ANDESITE(),
-				StringValues::STONE_TYPE_ANDESITE_SMOOTH => Blocks::POLISHED_ANDESITE(),
-				StringValues::STONE_TYPE_DIORITE => Blocks::DIORITE(),
-				StringValues::STONE_TYPE_DIORITE_SMOOTH => Blocks::POLISHED_DIORITE(),
-				StringValues::STONE_TYPE_GRANITE => Blocks::GRANITE(),
-				StringValues::STONE_TYPE_GRANITE_SMOOTH => Blocks::POLISHED_GRANITE(),
-				StringValues::STONE_TYPE_STONE => Blocks::STONE(),
-				default => throw $in->badValueException(StateNames::STONE_TYPE, $type),
-			};
-		});
+		$this->mapSlab(Ids::STONE_BRICK_SLAB, Ids::STONE_BRICK_DOUBLE_SLAB, fn() => Blocks::STONE_BRICK_SLAB());
 		$this->mapStairs(Ids::STONE_BRICK_STAIRS, fn() => Blocks::STONE_BRICK_STAIRS());
 		$this->map(Ids::STONE_BUTTON, fn(Reader $in) => Helper::decodeButton(Blocks::STONE_BUTTON(), $in));
 		$this->map(Ids::STONE_PRESSURE_PLATE, fn(Reader $in) => Helper::decodeSimplePressurePlate(Blocks::STONE_PRESSURE_PLATE(), $in));
-		$this->mapSlab(Ids::STONE_BLOCK_SLAB, Ids::DOUBLE_STONE_BLOCK_SLAB, fn(Reader $in) => Helper::mapStoneSlab1Type($in));
-		$this->mapSlab(Ids::STONE_BLOCK_SLAB2, Ids::DOUBLE_STONE_BLOCK_SLAB2, fn(Reader $in) => Helper::mapStoneSlab2Type($in));
-		$this->mapSlab(Ids::STONE_BLOCK_SLAB3, Ids::DOUBLE_STONE_BLOCK_SLAB3, fn(Reader $in) => Helper::mapStoneSlab3Type($in));
-		$this->mapSlab(Ids::STONE_BLOCK_SLAB4, Ids::DOUBLE_STONE_BLOCK_SLAB4, fn(Reader $in) => Helper::mapStoneSlab4Type($in));
 		$this->mapStairs(Ids::STONE_STAIRS, fn() => Blocks::COBBLESTONE_STAIRS());
-		$this->map(Ids::STONEBRICK, function(Reader $in) : Block{
-			return match($type = $in->readString(StateNames::STONE_BRICK_TYPE)){
-				StringValues::STONE_BRICK_TYPE_SMOOTH, //TODO: bug in vanilla
-				StringValues::STONE_BRICK_TYPE_DEFAULT => Blocks::STONE_BRICKS(),
-				StringValues::STONE_BRICK_TYPE_CHISELED => Blocks::CHISELED_STONE_BRICKS(),
-				StringValues::STONE_BRICK_TYPE_CRACKED => Blocks::CRACKED_STONE_BRICKS(),
-				StringValues::STONE_BRICK_TYPE_MOSSY => Blocks::MOSSY_STONE_BRICKS(),
-				default => throw $in->badValueException(StateNames::STONE_BRICK_TYPE, $type),
-			};
-		});
 		$this->map(Ids::STONECUTTER_BLOCK, function(Reader $in) : Block{
 			return Blocks::STONECUTTER()
 				->setFacing($in->readCardinalHorizontalFacing());
@@ -1568,13 +1591,6 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 			return Blocks::SWEET_BERRY_BUSH()
 				->setAge(min($growth, SweetBerryBush::STAGE_MATURE));
 		});
-		$this->map(Ids::TALLGRASS, function(Reader $in) : Block{
-			return match($type = $in->readString(StateNames::TALL_GRASS_TYPE)){
-				StringValues::TALL_GRASS_TYPE_DEFAULT, StringValues::TALL_GRASS_TYPE_SNOW, StringValues::TALL_GRASS_TYPE_TALL => Blocks::TALL_GRASS(),
-				StringValues::TALL_GRASS_TYPE_FERN => Blocks::FERN(),
-				default => throw $in->badValueException(StateNames::TALL_GRASS_TYPE, $type),
-			};
-		});
 		$this->map(Ids::TNT, function(Reader $in) : Block{
 			return Blocks::TNT()
 				->setUnstable($in->readBool(StateNames::EXPLODE_BIT))

src/data/bedrock/block/convert/BlockStateWriter.php

@@ -24,11 +24,8 @@ declare(strict_types=1);
 namespace pocketmine\data\bedrock\block\convert;
 
 use pocketmine\block\utils\BellAttachmentType;
-use pocketmine\block\utils\CoralType;
-use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\SlabType;
 use pocketmine\block\utils\WallConnectionType;
-use pocketmine\block\utils\WoodType;
 use pocketmine\data\bedrock\block\BlockLegacyMetadata;
 use pocketmine\data\bedrock\block\BlockStateData;
 use pocketmine\data\bedrock\block\BlockStateNames;
@@ -193,29 +190,6 @@ final class BlockStateWriter{
 		});
 	}
 
-	/** @return $this */
-	public function writeColor(DyeColor $color) : self{
-		$this->writeString(BlockStateNames::COLOR, match($color){
-			DyeColor::BLACK => StringValues::COLOR_BLACK,
-			DyeColor::BLUE => StringValues::COLOR_BLUE,
-			DyeColor::BROWN => StringValues::COLOR_BROWN,
-			DyeColor::CYAN => StringValues::COLOR_CYAN,
-			DyeColor::GRAY => StringValues::COLOR_GRAY,
-			DyeColor::GREEN => StringValues::COLOR_GREEN,
-			DyeColor::LIGHT_BLUE => StringValues::COLOR_LIGHT_BLUE,
-			DyeColor::LIGHT_GRAY => StringValues::COLOR_SILVER,
-			DyeColor::LIME => StringValues::COLOR_LIME,
-			DyeColor::MAGENTA => StringValues::COLOR_MAGENTA,
-			DyeColor::ORANGE => StringValues::COLOR_ORANGE,
-			DyeColor::PINK => StringValues::COLOR_PINK,
-			DyeColor::PURPLE => StringValues::COLOR_PURPLE,
-			DyeColor::RED => StringValues::COLOR_RED,
-			DyeColor::WHITE => StringValues::COLOR_WHITE,
-			DyeColor::YELLOW => StringValues::COLOR_YELLOW,
-		});
-		return $this;
-	}
-
 	/** @return $this */
 	public function writeCoralFacing(int $value) : self{
 		$this->writeInt(BlockStateNames::CORAL_DIRECTION, match($value){
@@ -281,32 +255,6 @@ final class BlockStateWriter{
 		return $this;
 	}
 
-	/** @return $this */
-	public function writeLegacyWoodType(WoodType $treeType) : self{
-		$this->writeString(BlockStateNames::WOOD_TYPE, match($treeType){
-			WoodType::OAK => StringValues::WOOD_TYPE_OAK,
-			WoodType::SPRUCE => StringValues::WOOD_TYPE_SPRUCE,
-			WoodType::BIRCH => StringValues::WOOD_TYPE_BIRCH,
-			WoodType::JUNGLE => StringValues::WOOD_TYPE_JUNGLE,
-			WoodType::ACACIA => StringValues::WOOD_TYPE_ACACIA,
-			WoodType::DARK_OAK => StringValues::WOOD_TYPE_DARK_OAK,
-			default => throw new BlockStateSerializeException("Invalid legacy wood type " . $treeType->name)
-		});
-		return $this;
-	}
-
-	/** @return $this */
-	public function writeCoralType(CoralType $coralType) : self{
-		$this->writeString(BlockStateNames::CORAL_COLOR, match($coralType){
-			CoralType::TUBE => StringValues::CORAL_COLOR_BLUE,
-			CoralType::BRAIN => StringValues::CORAL_COLOR_PINK,
-			CoralType::BUBBLE => StringValues::CORAL_COLOR_PURPLE,
-			CoralType::FIRE => StringValues::CORAL_COLOR_RED,
-			CoralType::HORN => StringValues::CORAL_COLOR_YELLOW,
-		});
-		return $this;
-	}
-
 	/** @return $this */
 	public function writeBellAttachmentType(BellAttachmentType $attachmentType) : self{
 		$this->writeString(BlockStateNames::ATTACHMENT, match($attachmentType){

src/data/bedrock/block/upgrade/BlockStateUpgradeSchema.php

@@ -64,20 +64,24 @@ final class BlockStateUpgradeSchema{
 	 */
 	public array $remappedStates = [];
 
+	public readonly int $versionId;
+
 	public function __construct(
-		public int $maxVersionMajor,
-		public int $maxVersionMinor,
-		public int $maxVersionPatch,
-		public int $maxVersionRevision,
+		public readonly int $maxVersionMajor,
+		public readonly int $maxVersionMinor,
+		public readonly int $maxVersionPatch,
+		public readonly int $maxVersionRevision,
 		private int $schemaId
-	){}
+	){
+		$this->versionId = ($this->maxVersionMajor << 24) | ($this->maxVersionMinor << 16) | ($this->maxVersionPatch << 8) | $this->maxVersionRevision;
+	}
 
 	/**
 	 * @deprecated This is defined by Mojang, and therefore cannot be relied on. Use getSchemaId() instead for
 	 * internal version management.
 	 */
 	public function getVersionId() : int{
-		return ($this->maxVersionMajor << 24) | ($this->maxVersionMinor << 16) | ($this->maxVersionPatch << 8) | $this->maxVersionRevision;
+		return $this->versionId;
 	}
 
 	public function getSchemaId() : int{ return $this->schemaId; }

src/data/bedrock/block/upgrade/BlockStateUpgradeSchemaFlattenedName.php

@@ -23,17 +23,28 @@ declare(strict_types=1);
 
 namespace pocketmine\data\bedrock\block\upgrade;
 
+use function ksort;
+use const SORT_STRING;
+
 final class BlockStateUpgradeSchemaFlattenedName{
 
+	/**
+	 * @param string[] $flattenedValueRemaps
+	 * @phpstan-param array<string, string> $flattenedValueRemaps
+	 */
 	public function __construct(
 		public string $prefix,
 		public string $flattenedProperty,
-		public string $suffix
-	){}
+		public string $suffix,
+		public array $flattenedValueRemaps
+	){
+		ksort($this->flattenedValueRemaps, SORT_STRING);
+	}
 
 	public function equals(self $that) : bool{
 		return $this->prefix === $that->prefix &&
 			$this->flattenedProperty === $that->flattenedProperty &&
-			$this->suffix === $that->suffix;
+			$this->suffix === $that->suffix &&
+			$this->flattenedValueRemaps === $that->flattenedValueRemaps;
 	}
 }

src/data/bedrock/block/upgrade/BlockStateUpgradeSchemaUtils.php

@@ -166,7 +166,8 @@ final class BlockStateUpgradeSchemaUtils{
 					$remap->newName ?? new BlockStateUpgradeSchemaFlattenedName(
 						$remap->newFlattenedName->prefix,
 						$remap->newFlattenedName->flattenedProperty,
-						$remap->newFlattenedName->suffix
+						$remap->newFlattenedName->suffix,
+						$remap->newFlattenedName->flattenedValueRemaps ?? [],
 					),
 					array_map(fn(BlockStateUpgradeSchemaModelTag $tag) => self::jsonModelToTag($tag), $remap->newState ?? []),
 					$remap->copiedState ?? []
@@ -301,7 +302,8 @@ final class BlockStateUpgradeSchemaUtils{
 						new BlockStateUpgradeSchemaModelFlattenedName(
 							$remap->newName->prefix,
 							$remap->newName->flattenedProperty,
-							$remap->newName->suffix
+							$remap->newName->suffix,
+							$remap->newName->flattenedValueRemaps
 						),
 					array_map(fn(Tag $tag) => self::tagToJsonModel($tag), $remap->newState),
 					$remap->copiedState
@@ -389,6 +391,9 @@ final class BlockStateUpgradeSchemaUtils{
 		}
 
 		$jsonMapper = new \JsonMapper();
+		$jsonMapper->bExceptionOnMissingData = true;
+		$jsonMapper->bExceptionOnUndefinedProperty = true;
+		$jsonMapper->bStrictObjectTypeChecking = true;
 		try{
 			$model = $jsonMapper->map($json, new BlockStateUpgradeSchemaModel());
 		}catch(\JsonMapper_Exception $e){

src/data/bedrock/block/upgrade/BlockStateUpgrader.php

@@ -35,9 +35,14 @@ use function sprintf;
 use const SORT_NUMERIC;
 
 final class BlockStateUpgrader{
-	/** @var BlockStateUpgradeSchema[] */
+	/**
+	 * @var BlockStateUpgradeSchema[][] versionId => [schemaId => schema]
+	 * @phpstan-var array<int, array<int, BlockStateUpgradeSchema>>
+	 */
 	private array $upgradeSchemas = [];
 
+	private int $outputVersion = 0;
+
 	/**
 	 * @param BlockStateUpgradeSchema[] $upgradeSchemas
 	 * @phpstan-param array<int, BlockStateUpgradeSchema> $upgradeSchemas
@@ -50,87 +55,116 @@ final class BlockStateUpgrader{
 
 	public function addSchema(BlockStateUpgradeSchema $schema) : void{
 		$schemaId = $schema->getSchemaId();
-		if(isset($this->upgradeSchemas[$schemaId])){
-			throw new \InvalidArgumentException("Cannot add two schemas with the same schema ID");
+		$versionId = $schema->getVersionId();
+		if(isset($this->upgradeSchemas[$versionId][$schemaId])){
+			throw new \InvalidArgumentException("Cannot add two schemas with the same schema ID and version ID");
 		}
-		$this->upgradeSchemas[$schemaId] = $schema;
+
+		//schema ID tells us the order when multiple schemas use the same version ID
+		$this->upgradeSchemas[$versionId][$schemaId] = $schema;
 
 		ksort($this->upgradeSchemas, SORT_NUMERIC);
+		ksort($this->upgradeSchemas[$versionId], SORT_NUMERIC);
+
+		$this->outputVersion = max($this->outputVersion, $schema->getVersionId());
 	}
 
 	public function upgrade(BlockStateData $blockStateData) : BlockStateData{
 		$version = $blockStateData->getVersion();
-		$highestVersion = $version;
-		foreach($this->upgradeSchemas as $schema){
-			$resultVersion = $schema->getVersionId();
-			$highestVersion = max($highestVersion, $resultVersion);
-			if($version > $resultVersion){
-				//even if this is actually the same version, we have to apply it anyway because mojang are dumb and
-				//didn't always bump the blockstate version when changing it :(
+		foreach($this->upgradeSchemas as $resultVersion => $schemaList){
+			/*
+			 * Sometimes Mojang made changes without bumping the version ID.
+			 * A notable example is 0131_1.18.20.27_beta_to_1.18.30.json, which renamed a bunch of blockIDs.
+			 * When this happens, all the schemas must be applied even if the version is the same, because the input
+			 * version doesn't tell us which of the schemas have already been applied.
+			 * If there's only one schema for a version (the norm), we can safely assume it's already been applied if
+			 * the version is the same, and skip over it.
+			 */
+			if($version > $resultVersion || (count($schemaList) === 1 && $version === $resultVersion)){
 				continue;
 			}
-			$oldName = $blockStateData->getName();
-			$oldState = $blockStateData->getStates();
-			if(isset($schema->remappedStates[$oldName])){
-				foreach($schema->remappedStates[$oldName] as $remap){
-					if(count($remap->oldState) > count($oldState)){
-						//match criteria has more requirements than we have state properties
-						continue; //try next state
-					}
-					foreach(Utils::stringifyKeys($remap->oldState) as $k => $v){
-						if(!isset($oldState[$k]) || !$oldState[$k]->equals($v)){
-							continue 2; //try next state
-						}
-					}
 
-					if(is_string($remap->newName)){
-						$newName = $remap->newName;
-					}else{
-						$flattenedValue = $oldState[$remap->newName->flattenedProperty] ?? null;
-						if($flattenedValue instanceof StringTag){
-							$newName = sprintf("%s%s%s", $remap->newName->prefix, $flattenedValue->getValue(), $remap->newName->suffix);
-							unset($oldState[$remap->newName->flattenedProperty]);
-						}else{
-							//flattened property is not a TAG_String, so this transformation is not applicable
-							continue;
-						}
-					}
-
-					$newState = $remap->newState;
-					foreach($remap->copiedState as $stateName){
-						if(isset($oldState[$stateName])){
-							$newState[$stateName] = $oldState[$stateName];
-						}
-					}
-
-					$blockStateData = new BlockStateData($newName, $newState, $resultVersion);
-					continue 2; //try next schema
-				}
-			}
-			$newName = $schema->renamedIds[$oldName] ?? null;
-
-			$stateChanges = 0;
-			$states = $blockStateData->getStates();
-
-			$states = $this->applyPropertyAdded($schema, $oldName, $states, $stateChanges);
-			$states = $this->applyPropertyRemoved($schema, $oldName, $states, $stateChanges);
-			$states = $this->applyPropertyRenamedOrValueChanged($schema, $oldName, $states, $stateChanges);
-			$states = $this->applyPropertyValueChanged($schema, $oldName, $states, $stateChanges);
-
-			if($newName !== null || $stateChanges > 0){
-				$blockStateData = new BlockStateData($newName ?? $oldName, $states, $resultVersion);
-				//don't break out; we may need to further upgrade the state
+			foreach($schemaList as $schema){
+				$blockStateData = $this->applySchema($schema, $blockStateData);
 			}
 		}
 
-		if($highestVersion > $version){
+		if($this->outputVersion > $version){
 			//always update the version number of the blockstate, even if it didn't change - this is needed for
 			//external tools
-			$blockStateData = new BlockStateData($blockStateData->getName(), $blockStateData->getStates(), $highestVersion);
+			$blockStateData = new BlockStateData($blockStateData->getName(), $blockStateData->getStates(), $this->outputVersion);
 		}
 		return $blockStateData;
 	}
 
+	private function applySchema(BlockStateUpgradeSchema $schema, BlockStateData $blockStateData) : BlockStateData{
+		$newStateData = $this->applyStateRemapped($schema, $blockStateData);
+		if($newStateData !== null){
+			return $newStateData;
+		}
+
+		$oldName = $blockStateData->getName();
+		$newName = $schema->renamedIds[$oldName] ?? null;
+
+		$stateChanges = 0;
+		$states = $blockStateData->getStates();
+
+		$states = $this->applyPropertyAdded($schema, $oldName, $states, $stateChanges);
+		$states = $this->applyPropertyRemoved($schema, $oldName, $states, $stateChanges);
+		$states = $this->applyPropertyRenamedOrValueChanged($schema, $oldName, $states, $stateChanges);
+		$states = $this->applyPropertyValueChanged($schema, $oldName, $states, $stateChanges);
+
+		if($newName !== null || $stateChanges > 0){
+			return new BlockStateData($newName ?? $oldName, $states, $schema->getVersionId());
+		}
+
+		return $blockStateData;
+	}
+
+	private function applyStateRemapped(BlockStateUpgradeSchema $schema, BlockStateData $blockStateData) : ?BlockStateData{
+		$oldName = $blockStateData->getName();
+		$oldState = $blockStateData->getStates();
+
+		if(isset($schema->remappedStates[$oldName])){
+			foreach($schema->remappedStates[$oldName] as $remap){
+				if(count($remap->oldState) > count($oldState)){
+					//match criteria has more requirements than we have state properties
+					continue; //try next state
+				}
+				foreach(Utils::stringifyKeys($remap->oldState) as $k => $v){
+					if(!isset($oldState[$k]) || !$oldState[$k]->equals($v)){
+						continue 2; //try next state
+					}
+				}
+
+				if(is_string($remap->newName)){
+					$newName = $remap->newName;
+				}else{
+					$flattenedValue = $oldState[$remap->newName->flattenedProperty] ?? null;
+					if($flattenedValue instanceof StringTag){
+						$embedValue = $remap->newName->flattenedValueRemaps[$flattenedValue->getValue()] ?? $flattenedValue->getValue();
+						$newName = sprintf("%s%s%s", $remap->newName->prefix, $embedValue, $remap->newName->suffix);
+						unset($oldState[$remap->newName->flattenedProperty]);
+					}else{
+						//flattened property is not a TAG_String, so this transformation is not applicable
+						continue;
+					}
+				}
+
+				$newState = $remap->newState;
+				foreach($remap->copiedState as $stateName){
+					if(isset($oldState[$stateName])){
+						$newState[$stateName] = $oldState[$stateName];
+					}
+				}
+
+				return new BlockStateData($newName, $newState, $schema->getVersionId());
+			}
+		}
+
+		return null;
+	}
+
 	/**
 	 * @param Tag[] $states
 	 * @phpstan-param array<string, Tag> $states

src/data/bedrock/block/upgrade/model/BlockStateUpgradeSchemaModelFlattenedName.php

@@ -23,7 +23,9 @@ declare(strict_types=1);
 
 namespace pocketmine\data\bedrock\block\upgrade\model;
 
-final class BlockStateUpgradeSchemaModelFlattenedName{
+use function count;
+
+final class BlockStateUpgradeSchemaModelFlattenedName implements \JsonSerializable{
 
 	/** @required */
 	public string $prefix;
@@ -31,10 +33,31 @@ final class BlockStateUpgradeSchemaModelFlattenedName{
 	public string $flattenedProperty;
 	/** @required */
 	public string $suffix;
+	/**
+	 * @var string[]
+	 * @phpstan-var array<string, string>
+	 */
+	public array $flattenedValueRemaps;
 
-	public function __construct(string $prefix, string $flattenedProperty, string $suffix){
+	/**
+	 * @param string[] $flattenedValueRemaps
+	 * @phpstan-param array<string, string> $flattenedValueRemaps
+	 */
+	public function __construct(string $prefix, string $flattenedProperty, string $suffix, array $flattenedValueRemaps){
 		$this->prefix = $prefix;
 		$this->flattenedProperty = $flattenedProperty;
 		$this->suffix = $suffix;
+		$this->flattenedValueRemaps = $flattenedValueRemaps;
+	}
+
+	/**
+	 * @return mixed[]
+	 */
+	public function jsonSerialize() : array{
+		$result = (array) $this;
+		if(count($this->flattenedValueRemaps) === 0){
+			unset($result["flattenedValueRemaps"]);
+		}
+		return $result;
 	}
 }

src/data/bedrock/item/ItemSerializerDeserializerRegistrar.php

@@ -147,7 +147,6 @@ final class ItemSerializerDeserializerRegistrar{
 		$this->map1to1Block(Ids::JUNGLE_DOOR, Blocks::JUNGLE_DOOR());
 		$this->map1to1Block(Ids::MANGROVE_DOOR, Blocks::MANGROVE_DOOR());
 		$this->map1to1Block(Ids::NETHER_WART, Blocks::NETHER_WART());
-		$this->map1to1Block(Ids::PITCHER_POD, Blocks::PITCHER_CROP());
 		$this->map1to1Block(Ids::REPEATER, Blocks::REDSTONE_REPEATER());
 		$this->map1to1Block(Ids::SPRUCE_DOOR, Blocks::SPRUCE_DOOR());
 		$this->map1to1Block(Ids::SUGAR_CANE, Blocks::SUGARCANE());
@@ -306,6 +305,7 @@ final class ItemSerializerDeserializerRegistrar{
 		$this->map1to1Item(Ids::MUSIC_DISC_WAIT, Items::RECORD_WAIT());
 		$this->map1to1Item(Ids::MUSIC_DISC_WARD, Items::RECORD_WARD());
 		$this->map1to1Item(Ids::MUTTON, Items::RAW_MUTTON());
+		$this->map1to1Item(Ids::NAME_TAG, Items::NAME_TAG());
 		$this->map1to1Item(Ids::NAUTILUS_SHELL, Items::NAUTILUS_SHELL());
 		$this->map1to1Item(Ids::NETHER_STAR, Items::NETHER_STAR());
 		$this->map1to1Item(Ids::NETHERBRICK, Items::NETHER_BRICK());
@@ -326,6 +326,7 @@ final class ItemSerializerDeserializerRegistrar{
 		$this->map1to1Item(Ids::PAINTING, Items::PAINTING());
 		$this->map1to1Item(Ids::PAPER, Items::PAPER());
 		$this->map1to1Item(Ids::PHANTOM_MEMBRANE, Items::PHANTOM_MEMBRANE());
+		$this->map1to1Item(Ids::PITCHER_POD, Items::PITCHER_POD());
 		$this->map1to1Item(Ids::POISONOUS_POTATO, Items::POISONOUS_POTATO());
 		$this->map1to1Item(Ids::POPPED_CHORUS_FRUIT, Items::POPPED_CHORUS_FRUIT());
 		$this->map1to1Item(Ids::PORKCHOP, Items::RAW_PORKCHOP());
@@ -348,7 +349,7 @@ final class ItemSerializerDeserializerRegistrar{
 		$this->map1to1Item(Ids::RIB_ARMOR_TRIM_SMITHING_TEMPLATE, Items::RIB_ARMOR_TRIM_SMITHING_TEMPLATE());
 		$this->map1to1Item(Ids::ROTTEN_FLESH, Items::ROTTEN_FLESH());
 		$this->map1to1Item(Ids::SALMON, Items::RAW_SALMON());
-		$this->map1to1Item(Ids::SCUTE, Items::SCUTE());
+		$this->map1to1Item(Ids::TURTLE_SCUTE, Items::SCUTE());
 		$this->map1to1Item(Ids::SENTRY_ARMOR_TRIM_SMITHING_TEMPLATE, Items::SENTRY_ARMOR_TRIM_SMITHING_TEMPLATE());
 		$this->map1to1Item(Ids::SHAPER_ARMOR_TRIM_SMITHING_TEMPLATE, Items::SHAPER_ARMOR_TRIM_SMITHING_TEMPLATE());
 		$this->map1to1Item(Ids::SHEARS, Items::SHEARS());

src/data/bedrock/item/ItemTypeNames.php

@@ -38,6 +38,8 @@ final class ItemTypeNames{
 	public const ANGLER_POTTERY_SHERD = "minecraft:angler_pottery_sherd";
 	public const APPLE = "minecraft:apple";
 	public const ARCHER_POTTERY_SHERD = "minecraft:archer_pottery_sherd";
+	public const ARMADILLO_SCUTE = "minecraft:armadillo_scute";
+	public const ARMADILLO_SPAWN_EGG = "minecraft:armadillo_spawn_egg";
 	public const ARMOR_STAND = "minecraft:armor_stand";
 	public const ARMS_UP_POTTERY_SHERD = "minecraft:arms_up_pottery_sherd";
 	public const ARROW = "minecraft:arrow";
@@ -72,6 +74,8 @@ final class ItemTypeNames{
 	public const BLEACH = "minecraft:bleach";
 	public const BLUE_DYE = "minecraft:blue_dye";
 	public const BOAT = "minecraft:boat";
+	public const BOGGED_SPAWN_EGG = "minecraft:bogged_spawn_egg";
+	public const BOLT_ARMOR_TRIM_SMITHING_TEMPLATE = "minecraft:bolt_armor_trim_smithing_template";
 	public const BONE = "minecraft:bone";
 	public const BONE_MEAL = "minecraft:bone_meal";
 	public const BOOK = "minecraft:book";
@@ -79,12 +83,15 @@ final class ItemTypeNames{
 	public const BOW = "minecraft:bow";
 	public const BOWL = "minecraft:bowl";
 	public const BREAD = "minecraft:bread";
+	public const BREEZE_ROD = "minecraft:breeze_rod";
+	public const BREEZE_SPAWN_EGG = "minecraft:breeze_spawn_egg";
 	public const BREWER_POTTERY_SHERD = "minecraft:brewer_pottery_sherd";
 	public const BREWING_STAND = "minecraft:brewing_stand";
 	public const BRICK = "minecraft:brick";
 	public const BROWN_DYE = "minecraft:brown_dye";
 	public const BRUSH = "minecraft:brush";
 	public const BUCKET = "minecraft:bucket";
+	public const BUNDLE = "minecraft:bundle";
 	public const BURN_POTTERY_SHERD = "minecraft:burn_pottery_sherd";
 	public const CAKE = "minecraft:cake";
 	public const CAMEL_SPAWN_EGG = "minecraft:camel_spawn_egg";
@@ -134,8 +141,12 @@ final class ItemTypeNames{
 	public const COOKED_RABBIT = "minecraft:cooked_rabbit";
 	public const COOKED_SALMON = "minecraft:cooked_salmon";
 	public const COOKIE = "minecraft:cookie";
+	public const COPPER_DOOR = "minecraft:copper_door";
 	public const COPPER_INGOT = "minecraft:copper_ingot";
 	public const CORAL = "minecraft:coral";
+	public const CORAL_BLOCK = "minecraft:coral_block";
+	public const CORAL_FAN = "minecraft:coral_fan";
+	public const CORAL_FAN_DEAD = "minecraft:coral_fan_dead";
 	public const COW_SPAWN_EGG = "minecraft:cow_spawn_egg";
 	public const CREEPER_BANNER_PATTERN = "minecraft:creeper_banner_pattern";
 	public const CREEPER_SPAWN_EGG = "minecraft:creeper_spawn_egg";
@@ -150,6 +161,7 @@ final class ItemTypeNames{
 	public const DARK_OAK_DOOR = "minecraft:dark_oak_door";
 	public const DARK_OAK_HANGING_SIGN = "minecraft:dark_oak_hanging_sign";
 	public const DARK_OAK_SIGN = "minecraft:dark_oak_sign";
+	public const DEBUG_STICK = "minecraft:debug_stick";
 	public const DIAMOND = "minecraft:diamond";
 	public const DIAMOND_AXE = "minecraft:diamond_axe";
 	public const DIAMOND_BOOTS = "minecraft:diamond_boots";
@@ -164,6 +176,11 @@ final class ItemTypeNames{
 	public const DISC_FRAGMENT_5 = "minecraft:disc_fragment_5";
 	public const DOLPHIN_SPAWN_EGG = "minecraft:dolphin_spawn_egg";
 	public const DONKEY_SPAWN_EGG = "minecraft:donkey_spawn_egg";
+	public const DOUBLE_PLANT = "minecraft:double_plant";
+	public const DOUBLE_STONE_BLOCK_SLAB = "minecraft:double_stone_block_slab";
+	public const DOUBLE_STONE_BLOCK_SLAB2 = "minecraft:double_stone_block_slab2";
+	public const DOUBLE_STONE_BLOCK_SLAB3 = "minecraft:double_stone_block_slab3";
+	public const DOUBLE_STONE_BLOCK_SLAB4 = "minecraft:double_stone_block_slab4";
 	public const DRAGON_BREATH = "minecraft:dragon_breath";
 	public const DRIED_KELP = "minecraft:dried_kelp";
 	public const DROWNED_SPAWN_EGG = "minecraft:drowned_spawn_egg";
@@ -186,6 +203,7 @@ final class ItemTypeNames{
 	public const EVOKER_SPAWN_EGG = "minecraft:evoker_spawn_egg";
 	public const EXPERIENCE_BOTTLE = "minecraft:experience_bottle";
 	public const EXPLORER_POTTERY_SHERD = "minecraft:explorer_pottery_sherd";
+	public const EXPOSED_COPPER_DOOR = "minecraft:exposed_copper_door";
 	public const EYE_ARMOR_TRIM_SMITHING_TEMPLATE = "minecraft:eye_armor_trim_smithing_template";
 	public const FEATHER = "minecraft:feather";
 	public const FENCE = "minecraft:fence";
@@ -198,6 +216,9 @@ final class ItemTypeNames{
 	public const FISHING_ROD = "minecraft:fishing_rod";
 	public const FLINT = "minecraft:flint";
 	public const FLINT_AND_STEEL = "minecraft:flint_and_steel";
+	public const FLOW_ARMOR_TRIM_SMITHING_TEMPLATE = "minecraft:flow_armor_trim_smithing_template";
+	public const FLOW_BANNER_PATTERN = "minecraft:flow_banner_pattern";
+	public const FLOW_POTTERY_SHERD = "minecraft:flow_pottery_sherd";
 	public const FLOWER_BANNER_PATTERN = "minecraft:flower_banner_pattern";
 	public const FLOWER_POT = "minecraft:flower_pot";
 	public const FOX_SPAWN_EGG = "minecraft:fox_spawn_egg";
@@ -235,6 +256,10 @@ final class ItemTypeNames{
 	public const GREEN_DYE = "minecraft:green_dye";
 	public const GUARDIAN_SPAWN_EGG = "minecraft:guardian_spawn_egg";
 	public const GUNPOWDER = "minecraft:gunpowder";
+	public const GUSTER_BANNER_PATTERN = "minecraft:guster_banner_pattern";
+	public const GUSTER_POTTERY_SHERD = "minecraft:guster_pottery_sherd";
+	public const HARD_STAINED_GLASS = "minecraft:hard_stained_glass";
+	public const HARD_STAINED_GLASS_PANE = "minecraft:hard_stained_glass_pane";
 	public const HEART_OF_THE_SEA = "minecraft:heart_of_the_sea";
 	public const HEART_POTTERY_SHERD = "minecraft:heart_pottery_sherd";
 	public const HEARTBREAK_POTTERY_SHERD = "minecraft:heartbreak_pottery_sherd";
@@ -278,6 +303,9 @@ final class ItemTypeNames{
 	public const LEATHER_HELMET = "minecraft:leather_helmet";
 	public const LEATHER_HORSE_ARMOR = "minecraft:leather_horse_armor";
 	public const LEATHER_LEGGINGS = "minecraft:leather_leggings";
+	public const LEAVES = "minecraft:leaves";
+	public const LEAVES2 = "minecraft:leaves2";
+	public const LIGHT_BLOCK = "minecraft:light_block";
 	public const LIGHT_BLUE_DYE = "minecraft:light_blue_dye";
 	public const LIGHT_GRAY_DYE = "minecraft:light_gray_dye";
 	public const LIME_DYE = "minecraft:lime_dye";
@@ -286,6 +314,7 @@ final class ItemTypeNames{
 	public const LODESTONE_COMPASS = "minecraft:lodestone_compass";
 	public const LOG = "minecraft:log";
 	public const LOG2 = "minecraft:log2";
+	public const MACE = "minecraft:mace";
 	public const MAGENTA_DYE = "minecraft:magenta_dye";
 	public const MAGMA_CREAM = "minecraft:magma_cream";
 	public const MAGMA_CUBE_SPAWN_EGG = "minecraft:magma_cube_spawn_egg";
@@ -301,6 +330,7 @@ final class ItemTypeNames{
 	public const MINECART = "minecraft:minecart";
 	public const MINER_POTTERY_SHERD = "minecraft:miner_pottery_sherd";
 	public const MOJANG_BANNER_PATTERN = "minecraft:mojang_banner_pattern";
+	public const MONSTER_EGG = "minecraft:monster_egg";
 	public const MOOSHROOM_SPAWN_EGG = "minecraft:mooshroom_spawn_egg";
 	public const MOURNER_POTTERY_SHERD = "minecraft:mourner_pottery_sherd";
 	public const MULE_SPAWN_EGG = "minecraft:mule_spawn_egg";
@@ -311,11 +341,14 @@ final class ItemTypeNames{
 	public const MUSIC_DISC_BLOCKS = "minecraft:music_disc_blocks";
 	public const MUSIC_DISC_CAT = "minecraft:music_disc_cat";
 	public const MUSIC_DISC_CHIRP = "minecraft:music_disc_chirp";
+	public const MUSIC_DISC_CREATOR = "minecraft:music_disc_creator";
+	public const MUSIC_DISC_CREATOR_MUSIC_BOX = "minecraft:music_disc_creator_music_box";
 	public const MUSIC_DISC_FAR = "minecraft:music_disc_far";
 	public const MUSIC_DISC_MALL = "minecraft:music_disc_mall";
 	public const MUSIC_DISC_MELLOHI = "minecraft:music_disc_mellohi";
 	public const MUSIC_DISC_OTHERSIDE = "minecraft:music_disc_otherside";
 	public const MUSIC_DISC_PIGSTEP = "minecraft:music_disc_pigstep";
+	public const MUSIC_DISC_PRECIPICE = "minecraft:music_disc_precipice";
 	public const MUSIC_DISC_RELIC = "minecraft:music_disc_relic";
 	public const MUSIC_DISC_STAL = "minecraft:music_disc_stal";
 	public const MUSIC_DISC_STRAD = "minecraft:music_disc_strad";
@@ -346,7 +379,10 @@ final class ItemTypeNames{
 	public const OAK_HANGING_SIGN = "minecraft:oak_hanging_sign";
 	public const OAK_SIGN = "minecraft:oak_sign";
 	public const OCELOT_SPAWN_EGG = "minecraft:ocelot_spawn_egg";
+	public const OMINOUS_BOTTLE = "minecraft:ominous_bottle";
+	public const OMINOUS_TRIAL_KEY = "minecraft:ominous_trial_key";
 	public const ORANGE_DYE = "minecraft:orange_dye";
+	public const OXIDIZED_COPPER_DOOR = "minecraft:oxidized_copper_door";
 	public const PAINTING = "minecraft:painting";
 	public const PANDA_SPAWN_EGG = "minecraft:panda_spawn_egg";
 	public const PAPER = "minecraft:paper";
@@ -360,6 +396,7 @@ final class ItemTypeNames{
 	public const PILLAGER_SPAWN_EGG = "minecraft:pillager_spawn_egg";
 	public const PINK_DYE = "minecraft:pink_dye";
 	public const PITCHER_POD = "minecraft:pitcher_pod";
+	public const PLANKS = "minecraft:planks";
 	public const PLENTY_POTTERY_SHERD = "minecraft:plenty_pottery_sherd";
 	public const POISONOUS_POTATO = "minecraft:poisonous_potato";
 	public const POLAR_BEAR_SPAWN_EGG = "minecraft:polar_bear_spawn_egg";
@@ -391,6 +428,7 @@ final class ItemTypeNames{
 	public const RAW_IRON = "minecraft:raw_iron";
 	public const RECOVERY_COMPASS = "minecraft:recovery_compass";
 	public const RED_DYE = "minecraft:red_dye";
+	public const RED_FLOWER = "minecraft:red_flower";
 	public const REDSTONE = "minecraft:redstone";
 	public const REPEATER = "minecraft:repeater";
 	public const RIB_ARMOR_TRIM_SMITHING_TEMPLATE = "minecraft:rib_armor_trim_smithing_template";
@@ -399,7 +437,8 @@ final class ItemTypeNames{
 	public const SALMON = "minecraft:salmon";
 	public const SALMON_BUCKET = "minecraft:salmon_bucket";
 	public const SALMON_SPAWN_EGG = "minecraft:salmon_spawn_egg";
-	public const SCUTE = "minecraft:scute";
+	public const SAPLING = "minecraft:sapling";
+	public const SCRAPE_POTTERY_SHERD = "minecraft:scrape_pottery_sherd";
 	public const SENTRY_ARMOR_TRIM_SMITHING_TEMPLATE = "minecraft:sentry_armor_trim_smithing_template";
 	public const SHAPER_ARMOR_TRIM_SMITHING_TEMPLATE = "minecraft:shaper_armor_trim_smithing_template";
 	public const SHEAF_POTTERY_SHERD = "minecraft:sheaf_pottery_sherd";
@@ -443,10 +482,15 @@ final class ItemTypeNames{
 	public const STAINED_HARDENED_CLAY = "minecraft:stained_hardened_clay";
 	public const STICK = "minecraft:stick";
 	public const STONE_AXE = "minecraft:stone_axe";
+	public const STONE_BLOCK_SLAB = "minecraft:stone_block_slab";
+	public const STONE_BLOCK_SLAB2 = "minecraft:stone_block_slab2";
+	public const STONE_BLOCK_SLAB3 = "minecraft:stone_block_slab3";
+	public const STONE_BLOCK_SLAB4 = "minecraft:stone_block_slab4";
 	public const STONE_HOE = "minecraft:stone_hoe";
 	public const STONE_PICKAXE = "minecraft:stone_pickaxe";
 	public const STONE_SHOVEL = "minecraft:stone_shovel";
 	public const STONE_SWORD = "minecraft:stone_sword";
+	public const STONEBRICK = "minecraft:stonebrick";
 	public const STRAY_SPAWN_EGG = "minecraft:stray_spawn_egg";
 	public const STRIDER_SPAWN_EGG = "minecraft:strider_spawn_egg";
 	public const STRING = "minecraft:string";
@@ -456,16 +500,19 @@ final class ItemTypeNames{
 	public const SWEET_BERRIES = "minecraft:sweet_berries";
 	public const TADPOLE_BUCKET = "minecraft:tadpole_bucket";
 	public const TADPOLE_SPAWN_EGG = "minecraft:tadpole_spawn_egg";
+	public const TALLGRASS = "minecraft:tallgrass";
 	public const TIDE_ARMOR_TRIM_SMITHING_TEMPLATE = "minecraft:tide_armor_trim_smithing_template";
 	public const TNT_MINECART = "minecraft:tnt_minecart";
 	public const TORCHFLOWER_SEEDS = "minecraft:torchflower_seeds";
 	public const TOTEM_OF_UNDYING = "minecraft:totem_of_undying";
 	public const TRADER_LLAMA_SPAWN_EGG = "minecraft:trader_llama_spawn_egg";
+	public const TRIAL_KEY = "minecraft:trial_key";
 	public const TRIDENT = "minecraft:trident";
 	public const TROPICAL_FISH = "minecraft:tropical_fish";
 	public const TROPICAL_FISH_BUCKET = "minecraft:tropical_fish_bucket";
 	public const TROPICAL_FISH_SPAWN_EGG = "minecraft:tropical_fish_spawn_egg";
 	public const TURTLE_HELMET = "minecraft:turtle_helmet";
+	public const TURTLE_SCUTE = "minecraft:turtle_scute";
 	public const TURTLE_SPAWN_EGG = "minecraft:turtle_spawn_egg";
 	public const VEX_ARMOR_TRIM_SMITHING_TEMPLATE = "minecraft:vex_armor_trim_smithing_template";
 	public const VEX_SPAWN_EGG = "minecraft:vex_spawn_egg";
@@ -479,20 +526,29 @@ final class ItemTypeNames{
 	public const WARPED_HANGING_SIGN = "minecraft:warped_hanging_sign";
 	public const WARPED_SIGN = "minecraft:warped_sign";
 	public const WATER_BUCKET = "minecraft:water_bucket";
+	public const WAXED_COPPER_DOOR = "minecraft:waxed_copper_door";
+	public const WAXED_EXPOSED_COPPER_DOOR = "minecraft:waxed_exposed_copper_door";
+	public const WAXED_OXIDIZED_COPPER_DOOR = "minecraft:waxed_oxidized_copper_door";
+	public const WAXED_WEATHERED_COPPER_DOOR = "minecraft:waxed_weathered_copper_door";
 	public const WAYFINDER_ARMOR_TRIM_SMITHING_TEMPLATE = "minecraft:wayfinder_armor_trim_smithing_template";
+	public const WEATHERED_COPPER_DOOR = "minecraft:weathered_copper_door";
 	public const WHEAT = "minecraft:wheat";
 	public const WHEAT_SEEDS = "minecraft:wheat_seeds";
 	public const WHITE_DYE = "minecraft:white_dye";
 	public const WILD_ARMOR_TRIM_SMITHING_TEMPLATE = "minecraft:wild_armor_trim_smithing_template";
+	public const WIND_CHARGE = "minecraft:wind_charge";
 	public const WITCH_SPAWN_EGG = "minecraft:witch_spawn_egg";
 	public const WITHER_SKELETON_SPAWN_EGG = "minecraft:wither_skeleton_spawn_egg";
 	public const WITHER_SPAWN_EGG = "minecraft:wither_spawn_egg";
+	public const WOLF_ARMOR = "minecraft:wolf_armor";
 	public const WOLF_SPAWN_EGG = "minecraft:wolf_spawn_egg";
+	public const WOOD = "minecraft:wood";
 	public const WOODEN_AXE = "minecraft:wooden_axe";
 	public const WOODEN_DOOR = "minecraft:wooden_door";
 	public const WOODEN_HOE = "minecraft:wooden_hoe";
 	public const WOODEN_PICKAXE = "minecraft:wooden_pickaxe";
 	public const WOODEN_SHOVEL = "minecraft:wooden_shovel";
+	public const WOODEN_SLAB = "minecraft:wooden_slab";
 	public const WOODEN_SWORD = "minecraft:wooden_sword";
 	public const WOOL = "minecraft:wool";
 	public const WRITABLE_BOOK = "minecraft:writable_book";

src/data/bedrock/item/upgrade/ItemIdMetaUpgradeSchemaUtils.php

@@ -88,6 +88,9 @@ final class ItemIdMetaUpgradeSchemaUtils{
 		}
 
 		$jsonMapper = new \JsonMapper();
+		$jsonMapper->bExceptionOnMissingData = true;
+		$jsonMapper->bExceptionOnUndefinedProperty = true;
+		$jsonMapper->bStrictObjectTypeChecking = true;
 		try{
 			$model = $jsonMapper->map($json, new ItemIdMetaUpgradeSchemaModel());
 		}catch(\JsonMapper_Exception $e){

src/data/java/GameModeIdMap.php

@@ -44,10 +44,14 @@ final class GameModeIdMap{
 	private array $enumToId = [];
 
 	public function __construct(){
-		$this->register(0, GameMode::SURVIVAL);
-		$this->register(1, GameMode::CREATIVE);
-		$this->register(2, GameMode::ADVENTURE);
-		$this->register(3, GameMode::SPECTATOR);
+		foreach(GameMode::cases() as $case){
+			$this->register(match($case){
+				GameMode::SURVIVAL => 0,
+				GameMode::CREATIVE => 1,
+				GameMode::ADVENTURE => 2,
+				GameMode::SPECTATOR => 3,
+			}, $case);
+		}
 	}
 
 	private function register(int $id, GameMode $type) : void{

src/data/runtime/LegacyRuntimeEnumDescriberTrait.php

@@ -29,11 +29,6 @@ namespace pocketmine\data\runtime;
  * @deprecated
  */
 trait LegacyRuntimeEnumDescriberTrait{
-
-	/**
-	 * @phpstan-template T of \UnitEnum
-	 * @phpstan-param T $case
-	 */
 	abstract protected function enum(\UnitEnum &$case) : void;
 
 	public function bellAttachmentType(\pocketmine\block\utils\BellAttachmentType &$value) : void{

src/data/runtime/RuntimeDataDescriber.php

@@ -89,10 +89,6 @@ interface RuntimeDataDescriber extends RuntimeEnumDescriber{
 
 	public function straightOnlyRailShape(int &$railShape) : void;
 
-	/**
-	 * @phpstan-template T of \UnitEnum
-	 * @phpstan-param T $case
-	 */
 	public function enum(\UnitEnum &$case) : void;
 
 	/**

src/entity/Entity.php

@@ -252,6 +252,14 @@ abstract class Entity{
 		return $this->alwaysShowNameTag;
 	}
 
+	/**
+	 * Returns whether players can rename this entity using a name tag.
+	 * Note that plugins can still name entities using setNameTag().
+	 */
+	public function canBeRenamed() : bool{
+		return false;
+	}
+
 	public function setNameTag(string $name) : void{
 		$this->nameTag = $name;
 		$this->networkPropertiesDirty = true;
@@ -792,7 +800,7 @@ abstract class Entity{
 	}
 
 	protected function broadcastMotion() : void{
-		NetworkBroadcastUtils::broadcastPackets($this->hasSpawned, [SetActorMotionPacket::create($this->id, $this->getMotion())]);
+		NetworkBroadcastUtils::broadcastPackets($this->hasSpawned, [SetActorMotionPacket::create($this->id, $this->getMotion(), tick: 0)]);
 	}
 
 	public function getGravity() : float{

src/entity/Living.php

@@ -68,6 +68,7 @@ use function atan2;
 use function ceil;
 use function count;
 use function floor;
+use function ksort;
 use function lcg_value;
 use function max;
 use function min;
@@ -76,6 +77,7 @@ use function mt_rand;
 use function round;
 use function sqrt;
 use const M_PI;
+use const SORT_NUMERIC;
 
 abstract class Living extends Entity{
 	protected const DEFAULT_BREATH_TICKS = 300;
@@ -132,6 +134,10 @@ abstract class Living extends Entity{
 
 	abstract public function getName() : string;
 
+	public function canBeRenamed() : bool{
+		return true;
+	}
+
 	protected function initEntity(CompoundTag $nbt) : void{
 		parent::initEntity($nbt);
 
@@ -551,26 +557,33 @@ abstract class Living extends Entity{
 			return;
 		}
 
-		$this->attackTime = $source->getAttackCooldown();
+		if($this->attackTime <= 0){
+			//this logic only applies if the entity was cold attacked
 
-		if($source instanceof EntityDamageByChildEntityEvent){
-			$e = $source->getChild();
-			if($e !== null){
-				$motion = $e->getMotion();
-				$this->knockBack($motion->x, $motion->z, $source->getKnockBack(), $source->getVerticalKnockBackLimit());
+			$this->attackTime = $source->getAttackCooldown();
+
+			if($source instanceof EntityDamageByChildEntityEvent){
+				$e = $source->getChild();
+				if($e !== null){
+					$motion = $e->getMotion();
+					$this->knockBack($motion->x, $motion->z, $source->getKnockBack(), $source->getVerticalKnockBackLimit());
+				}
+			}elseif($source instanceof EntityDamageByEntityEvent){
+				$e = $source->getDamager();
+				if($e !== null){
+					$deltaX = $this->location->x - $e->location->x;
+					$deltaZ = $this->location->z - $e->location->z;
+					$this->knockBack($deltaX, $deltaZ, $source->getKnockBack(), $source->getVerticalKnockBackLimit());
+				}
 			}
-		}elseif($source instanceof EntityDamageByEntityEvent){
-			$e = $source->getDamager();
-			if($e !== null){
-				$deltaX = $this->location->x - $e->location->x;
-				$deltaZ = $this->location->z - $e->location->z;
-				$this->knockBack($deltaX, $deltaZ, $source->getKnockBack(), $source->getVerticalKnockBackLimit());
+
+			if($this->isAlive()){
+				$this->doHitAnimation();
 			}
 		}
 
 		if($this->isAlive()){
 			$this->applyPostDamageEffects($source);
-			$this->doHitAnimation();
 		}
 	}
 
@@ -872,8 +885,30 @@ abstract class Living extends Entity{
 	protected function syncNetworkData(EntityMetadataCollection $properties) : void{
 		parent::syncNetworkData($properties);
 
-		$properties->setByte(EntityMetadataProperties::POTION_AMBIENT, $this->effectManager->hasOnlyAmbientEffects() ? 1 : 0);
-		$properties->setInt(EntityMetadataProperties::POTION_COLOR, Binary::signInt($this->effectManager->getBubbleColor()->toARGB()));
+		$visibleEffects = [];
+		foreach ($this->effectManager->all() as $effect) {
+			if (!$effect->isVisible() || !$effect->getType()->hasBubbles()) {
+				continue;
+			}
+			$visibleEffects[EffectIdMap::getInstance()->toId($effect->getType())] = $effect->isAmbient();
+		}
+
+		//TODO: HACK! the client may not be able to identify effects if they are not sorted.
+		ksort($visibleEffects, SORT_NUMERIC);
+
+		$effectsData = 0;
+		$packedEffectsCount = 0;
+		foreach ($visibleEffects as $effectId => $isAmbient) {
+			$effectsData = ($effectsData << 7) |
+				(($effectId & 0x3f) << 1) | //Why not use 7 bits instead of only 6? mojang...
+				($isAmbient ? 1 : 0);
+
+			if (++$packedEffectsCount >= 8) {
+				break;
+			}
+		}
+		$properties->setLong(EntityMetadataProperties::VISIBLE_MOB_EFFECTS, $effectsData);
+
 		$properties->setShort(EntityMetadataProperties::AIR, $this->breathTicks);
 		$properties->setShort(EntityMetadataProperties::MAX_AIR, $this->maxBreathTicks);
 

src/entity/projectile/Projectile.php

@@ -173,8 +173,9 @@ abstract class Projectile extends Entity{
 		$entityHit = null;
 		$hitResult = null;
 
+		$world = $this->getWorld();
 		foreach(VoxelRayTrace::betweenPoints($start, $end) as $vector3){
-			$block = $this->getWorld()->getBlockAt($vector3->x, $vector3->y, $vector3->z);
+			$block = $world->getBlockAt($vector3->x, $vector3->y, $vector3->z);
 
 			$blockHitResult = $this->calculateInterceptWithBlock($block, $start, $end);
 			if($blockHitResult !== null){
@@ -188,7 +189,7 @@ abstract class Projectile extends Entity{
 		$entityDistance = PHP_INT_MAX;
 
 		$newDiff = $end->subtractVector($start);
-		foreach($this->getWorld()->getCollidingEntities($this->boundingBox->addCoord($newDiff->x, $newDiff->y, $newDiff->z)->expand(1, 1, 1), $this) as $entity){
+		foreach($world->getCollidingEntities($this->boundingBox->addCoord($newDiff->x, $newDiff->y, $newDiff->z)->expand(1, 1, 1), $this) as $entity){
 			if($entity->getId() === $this->getOwningEntityId() && $this->ticksLived < 5){
 				continue;
 			}
@@ -256,7 +257,7 @@ abstract class Projectile extends Entity{
 			);
 		}
 
-		$this->getWorld()->onEntityMoved($this);
+		$world->onEntityMoved($this);
 		$this->checkBlockIntersections();
 
 		Timings::$projectileMove->stopTiming();

src/entity/projectile/Snowball.php

@@ -31,8 +31,9 @@ class Snowball extends Throwable{
 	public static function getNetworkTypeId() : string{ return EntityIds::SNOWBALL; }
 
 	protected function onHit(ProjectileHitEvent $event) : void{
+		$world = $this->getWorld();
 		for($i = 0; $i < 6; ++$i){
-			$this->getWorld()->addParticle($this->location, new SnowballPoofParticle());
+			$world->addParticle($this->location, new SnowballPoofParticle());
 		}
 	}
 }

src/event/HandlerList.php

@@ -37,8 +37,7 @@ class HandlerList{
 	private array $affectedHandlerCaches = [];
 
 	/**
-	 * @phpstan-template TEvent of Event
-	 * @phpstan-param class-string<TEvent> $class
+	 * @phpstan-param class-string<covariant Event> $class
 	 */
 	public function __construct(
 		private string $class,

src/event/HandlerListManager.php

@@ -86,8 +86,7 @@ class HandlerListManager{
 	 *
 	 * Calling this method also lazily initializes the $classMap inheritance tree of handler lists.
 	 *
-	 * @phpstan-template TEvent of Event
-	 * @phpstan-param class-string<TEvent> $event
+	 * @phpstan-param class-string<covariant Event> $event
 	 *
 	 * @throws \ReflectionException
 	 * @throws \InvalidArgumentException
@@ -113,8 +112,7 @@ class HandlerListManager{
 	}
 
 	/**
-	 * @phpstan-template TEvent of Event
-	 * @phpstan-param class-string<TEvent> $event
+	 * @phpstan-param class-string<covariant Event> $event
 	 *
 	 * @return RegisteredListener[]
 	 */

src/event/player/PlayerResourcePackOfferEvent.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\event\player;
+
+use pocketmine\event\Event;
+use pocketmine\player\PlayerInfo;
+use pocketmine\resourcepacks\ResourcePack;
+use function array_unshift;
+
+/**
+ * Called after a player authenticates and is being offered resource packs to download.
+ *
+ * This event should be used to decide which resource packs to offer the player and whether to require the player to
+ * download the packs before they can join the server.
+ */
+class PlayerResourcePackOfferEvent extends Event{
+	/**
+	 * @param ResourcePack[] $resourcePacks
+	 * @param string[]       $encryptionKeys pack UUID => key, leave unset for any packs that are not encrypted
+	 *
+	 * @phpstan-param list<ResourcePack>    $resourcePacks
+	 * @phpstan-param array<string, string> $encryptionKeys
+	 */
+	public function __construct(
+		private readonly PlayerInfo $playerInfo,
+		private array $resourcePacks,
+		private array $encryptionKeys,
+		private bool $mustAccept
+	){}
+
+	public function getPlayerInfo() : PlayerInfo{
+		return $this->playerInfo;
+	}
+
+	/**
+	 * Adds a resource pack to the top of the stack.
+	 * The resources in this pack will be applied over the top of any existing packs.
+	 */
+	public function addResourcePack(ResourcePack $entry, ?string $encryptionKey = null) : void{
+		array_unshift($this->resourcePacks, $entry);
+		if($encryptionKey !== null){
+			$this->encryptionKeys[$entry->getPackId()] = $encryptionKey;
+		}
+	}
+
+	/**
+	 * Sets the resource packs to offer. Packs are applied from the highest key to the lowest, with each pack
+	 * overwriting any resources from the previous pack. This means that the pack at index 0 gets the final say on which
+	 * resources are used.
+	 *
+	 * @param ResourcePack[] $resourcePacks
+	 * @param string[]       $encryptionKeys pack UUID => key, leave unset for any packs that are not encrypted
+	 *
+	 * @phpstan-param list<ResourcePack>    $resourcePacks
+	 * @phpstan-param array<string, string> $encryptionKeys
+	 */
+	public function setResourcePacks(array $resourcePacks, array $encryptionKeys) : void{
+		$this->resourcePacks = $resourcePacks;
+		$this->encryptionKeys = $encryptionKeys;
+	}
+
+	/**
+	 * @return ResourcePack[]
+	 * @phpstan-return list<ResourcePack>
+	 */
+	public function getResourcePacks() : array{
+		return $this->resourcePacks;
+	}
+
+	/**
+	 * @return string[]
+	 * @phpstan-return array<string, string>
+	 */
+	public function getEncryptionKeys() : array{
+		return $this->encryptionKeys;
+	}
+
+	public function setMustAccept(bool $mustAccept) : void{
+		$this->mustAccept = $mustAccept;
+	}
+
+	public function mustAccept() : bool{
+		return $this->mustAccept;
+	}
+}

src/item/Armor.php

@@ -146,6 +146,10 @@ class Armor extends Durable{
 		$new = $thisCopy->pop();
 		$player->getArmorInventory()->setItem($this->getArmorSlot(), $new);
 		$player->getInventory()->setItemInHand($existing);
+		$sound = $new->getMaterial()->getEquipSound();
+		if($sound !== null){
+			$player->broadcastSound($sound);
+		}
 		if(!$thisCopy->isNull()){
 			//if the stack size was bigger than 1 (usually won't happen, but might be caused by plugins)
 			$returnedItems[] = $thisCopy;

src/item/ArmorMaterial.php

@@ -23,10 +23,13 @@ declare(strict_types=1);
 
 namespace pocketmine\item;
 
+use pocketmine\world\sound\Sound;
+
 class ArmorMaterial{
 
 	public function __construct(
-		private readonly int $enchantability
+		private readonly int $enchantability,
+		private readonly ?Sound $equipSound = null
 	){
 	}
 
@@ -39,4 +42,11 @@ class ArmorMaterial{
 	public function getEnchantability() : int{
 		return $this->enchantability;
 	}
+
+	/**
+	 * Returns the sound that plays when equipping the armor
+	 */
+	public function getEquipSound() : ?Sound{
+		return $this->equipSound;
+	}
 }

src/item/Bowl.php

@@ -25,5 +25,7 @@ namespace pocketmine\item;
 
 class Bowl extends Item{
 
-	//TODO: check fuel
+	public function getFuelTime() : int{
+		return 200;
+	}
 }

src/item/ItemBlock.php

@@ -24,6 +24,7 @@ declare(strict_types=1);
 namespace pocketmine\item;
 
 use pocketmine\block\Block;
+use pocketmine\block\BlockTypeIds;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 
 /**
@@ -58,4 +59,12 @@ final class ItemBlock extends Item{
 	public function getMaxStackSize() : int{
 		return $this->block->getMaxStackSize();
 	}
+
+	public function isNull() : bool{
+		//TODO: we really shouldn't need to treat air as a special case here
+		//this is needed because the "null" empty slot item is represented by an air block, but there's no real reason
+		//why air should be needed at all. A separate special item type (or actual null) should be used instead, but
+		//this would cause a lot of BC breaks, so we can't do it yet.
+		return parent::isNull() || $this->block->getTypeId() === BlockTypeIds::AIR;
+	}
 }