Fixup exception handling

Automatic merge performed by: https://github.com/pmmp/RestrictedActions/actions/runs/17629911301

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

@@ -18,9 +18,9 @@ jobs:
       - uses: actions/checkout@v5
 
       - name: Setup PHP and tools
-        uses: shivammathur/setup-php@2.35.3
+        uses: shivammathur/setup-php@2.35.4
         with:
-          php-version: 8.3
+          php-version: 8.2
 
       - name: Restore Composer package cache
         uses: actions/cache@v4

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

@@ -49,9 +49,9 @@ jobs:
       - uses: actions/checkout@v5
 
       - name: Setup PHP
-        uses: shivammathur/setup-php@2.35.3
+        uses: shivammathur/setup-php@2.35.4
         with:
-          php-version: 8.3
+          php-version: 8.2
 
       - name: Restore Composer package cache
         uses: actions/cache@v4

.github/workflows/draft-release.yml

@@ -18,7 +18,7 @@ on:
       - "*"
 
 env:
-  PHP_VERSION: "8.3"
+  PHP_VERSION: "8.2"
 
 jobs:
   skip:
@@ -87,7 +87,7 @@ jobs:
           submodules: true
 
       - name: Setup PHP
-        uses: shivammathur/setup-php@2.35.3
+        uses: shivammathur/setup-php@2.35.4
         with:
           php-version: ${{ env.PHP_VERSION }}
 

.github/workflows/main.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        php: ["8.3"]
+        php: ["8.1", "8.2", "8.3", "8.4"]
 
     uses: ./.github/workflows/main-php-matrix.yml
     with:
@@ -28,7 +28,7 @@ jobs:
       - uses: actions/checkout@v5
 
       - name: Setup PHP and tools
-        uses: shivammathur/setup-php@2.35.3
+        uses: shivammathur/setup-php@2.35.4
         with:
           php-version: 8.3
           tools: php-cs-fixer:3.75

.gitmodules

@@ -1,3 +1,6 @@
+[submodule "tests/plugins/DevTools"]
+	path = tests/plugins/DevTools
+	url = https://github.com/pmmp/DevTools.git
 [submodule "build/php"]
 	path = build/php
 	url = https://github.com/pmmp/php-build-scripts.git

.php-cs-fixer.php

@@ -5,7 +5,7 @@ $finder = PhpCsFixer\Finder::create()
 	->in(__DIR__ . '/build')
 	->in(__DIR__ . '/tests')
 	->in(__DIR__ . '/tools')
-
+	->notPath('plugins/DevTools')
 	//JsonMapper will break if the FQNs in the doc comments for these are shortened :(
 	->notPath('crafting/json')
 	->notPath('inventory/json')

README.md

@@ -73,7 +73,7 @@ PocketMine-MP is free, but it requires a lot of time and effort from unpaid volu
 You can support development using the following methods:
 
 - [Patreon](https://www.patreon.com/pocketminemp)
-- Bitcoin (BTC): `171u8K9e4FtU6j3e5sqNoxKUgEw9qWQdRV`
+- Bitcoin (BTC): `bc1q2v5ngyf8ugyd55kqa9ep35g2rv342ueqm6ks33`
 - Stellar Lumens (XLM): `GAAC5WZ33HCTE3BFJFZJXONMEIBNHFLBXM2HJVAZHXXPYA3HP5XPPS7T`
 
 Thanks for your support!

changelogs/5.33.md

@@ -127,3 +127,9 @@ Consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if
 ## Internals
 - `BlockStateUpgrader` is now almost entirely independent from `BlockStateData`. It's anticipated that the upgrader library will be separable from the core in the future.
 - `Block->readStateFromWorld()` is now triggered on chunk load for any position containing a tile. This should allow more effective updating of blocks with properties in their tiles.
+
+# 5.33.1
+Released 31st August 2025.
+
+## Fixes
+- Fixed banners placed in prior versions getting their tiles deleted (due to missing `Type` tags).

composer.json

@@ -5,13 +5,14 @@
    "homepage": "https://pmmp.io",
    "license": "LGPL-3.0",
    "require": {
-      "php": "^8.3",
+      "php": "^8.1",
       "php-64bit": "*",
       "ext-chunkutils2": "^0.3.1",
       "ext-crypto": "^0.3.1",
       "ext-ctype": "*",
       "ext-curl": "*",
       "ext-date": "*",
+      "ext-encoding": "~1.0.0",
       "ext-gmp": "*",
       "ext-hash": "*",
       "ext-igbinary": "^3.0.1",
@@ -36,26 +37,26 @@
       "pocketmine/bedrock-block-upgrade-schema": "~5.1.0+bedrock-1.21.60",
       "pocketmine/bedrock-data": "~6.0.0+bedrock-1.21.100",
       "pocketmine/bedrock-item-upgrade-schema": "~1.15.0+bedrock-1.21.100",
-      "pocketmine/bedrock-protocol": "~40.0.0+bedrock-1.21.100",
+      "pocketmine/bedrock-protocol": "dev-ext-encoding",
       "pocketmine/binaryutils": "^0.2.1",
-      "pocketmine/callback-validator": "dev-rewrite",
+      "pocketmine/callback-validator": "^1.0.2",
       "pocketmine/color": "^0.3.0",
       "pocketmine/errorhandler": "^0.7.0",
       "pocketmine/locale-data": "~2.25.0",
       "pocketmine/log": "^0.4.0",
-      "pocketmine/math": "dev-major-next as 1.0.0",
-      "pocketmine/nbt": "~1.1.0",
-      "pocketmine/raklib": "~1.2.0",
-      "pocketmine/raklib-ipc": "~1.0.0",
+      "pocketmine/math": "~1.0.0",
+      "pocketmine/nbt": "dev-ext-encoding as 1.1.1",
+      "pocketmine/raklib": "dev-ext-encoding as 1.2.0",
+      "pocketmine/raklib-ipc": "dev-ext-encoding as 1.0.0",
       "pocketmine/snooze": "^0.5.0",
       "ramsey/uuid": "~4.9.0",
-      "symfony/filesystem": "~7.3.0"
+      "symfony/filesystem": "~6.4.0"
    },
    "require-dev": {
       "phpstan/phpstan": "2.1.17",
       "phpstan/phpstan-phpunit": "^2.0.0",
       "phpstan/phpstan-strict-rules": "^2.0.0",
-      "phpunit/phpunit": "^12.2.1"
+      "phpunit/phpunit": "^10.5.24"
    },
    "replace": {
       "symfony/polyfill-ctype": "*",
@@ -77,11 +78,12 @@
    },
    "config": {
       "platform": {
-         "php": "8.3.0"
+         "php": "8.1.0"
       },
       "sort-packages": true
    },
    "scripts": {
+      "make-devtools": "@php -dphar.readonly=0 tests/plugins/DevTools/src/ConsoleScript.php --make ./ --relative tests/plugins/DevTools --out plugins/DevTools.phar",
       "make-server": [
          "@composer install --no-dev --classmap-authoritative --ignore-platform-reqs",
          "@php -dphar.readonly=0 build/server-phar.php"

phpstan.neon.dist

@@ -4,13 +4,17 @@ includes:
 	- tests/phpstan/configs/impossible-generics.neon
 	- tests/phpstan/configs/php-bugs.neon
 	- tests/phpstan/configs/phpstan-bugs.neon
+	- tests/phpstan/configs/property-hook-sadness.neon
+	- tests/phpstan/configs/reflection-class-sadness.neon
 	- tests/phpstan/configs/spl-fixed-array-sucks.neon
 	- vendor/phpstan/phpstan-phpunit/extension.neon
 	- vendor/phpstan/phpstan-phpunit/rules.neon
 	- vendor/phpstan/phpstan-strict-rules/rules.neon
 
 rules:
+	- pocketmine\phpstan\rules\DeprecatedLegacyEnumAccessRule
 	- pocketmine\phpstan\rules\DisallowDynamicNewRule
+	- pocketmine\phpstan\rules\DisallowEnumComparisonRule
 	- pocketmine\phpstan\rules\DisallowForeachByReferenceRule
 	- pocketmine\phpstan\rules\ExplodeLimitRule
 	- pocketmine\phpstan\rules\UnsafeForeachRule

src/MemoryManager.php

@@ -123,6 +123,13 @@ class MemoryManager{
 		return $this->globalMemoryLimit;
 	}
 
+	/**
+	 * @deprecated
+	 */
+	public function canUseChunkCache() : bool{
+		return !$this->lowMemory;
+	}
+
 	/**
 	 * Returns the allowed chunk radius based on the current memory usage.
 	 */
@@ -229,4 +236,13 @@ class MemoryManager{
 			}
 		}
 	}
+
+	/**
+	 * Static memory dumper accessible from any thread.
+	 * @deprecated
+	 * @see MemoryDump
+	 */
+	public static function dumpMemory(mixed $startingObject, string $outputFolder, int $maxNesting, int $maxStringSize, \Logger $logger) : void{
+		MemoryDump::dumpMemory($startingObject, $outputFolder, $maxNesting, $maxStringSize, $logger);
+	}
 }

src/PocketMine.php

@@ -55,7 +55,7 @@ namespace pocketmine {
 
 	require_once __DIR__ . '/VersionInfo.php';
 
-	const MIN_PHP_VERSION = "8.3.0";
+	const MIN_PHP_VERSION = "8.1.0";
 
 	/**
 	 * @param string $message
@@ -98,6 +98,7 @@ namespace pocketmine {
 			"crypto" => "php-crypto",
 			"ctype" => "ctype",
 			"date" => "Date",
+			"encoding" => "pmmp/ext-encoding",
 			"gmp" => "GMP",
 			"hash" => "Hash",
 			"igbinary" => "igbinary",
@@ -155,6 +156,12 @@ namespace pocketmine {
 			}
 		}
 
+		if(($encoding_version = phpversion("encoding")) !== false){
+			if(version_compare($encoding_version, "1.0.0") < 0 || version_compare($encoding_version, "2.0.0") >= 0){
+				$messages[] = "pmmp/ext-encoding ^1.0.0 is required, while you have $encoding_version.";
+			}
+		}
+
 		if(extension_loaded("pocketmine")){
 			$messages[] = "The native PocketMine extension is no longer supported.";
 		}

src/Server.php

@@ -80,7 +80,6 @@ use pocketmine\player\PlayerDataLoadException;
 use pocketmine\player\PlayerDataProvider;
 use pocketmine\player\PlayerDataSaveException;
 use pocketmine\player\PlayerInfo;
-use pocketmine\plugin\FolderPluginLoader;
 use pocketmine\plugin\PharPluginLoader;
 use pocketmine\plugin\PluginEnableOrder;
 use pocketmine\plugin\PluginGraylist;
@@ -347,10 +346,6 @@ class Server{
 		return $this->maxPlayers;
 	}
 
-	public function setMaxPlayers(int $maxPlayers) : void{
-		$this->maxPlayers = $maxPlayers;
-	}
-
 	/**
 	 * Returns whether the server requires that players be authenticated to Xbox Live. If true, connecting players who
 	 * are not logged into Xbox Live will be disconnected.
@@ -1034,7 +1029,6 @@ class Server{
 			$this->pluginManager = new PluginManager($this, $this->configGroup->getPropertyBool(Yml::PLUGINS_LEGACY_DATA_DIR, true) ? null : Path::join($this->dataPath, "plugin_data"), $pluginGraylist);
 			$this->pluginManager->registerInterface(new PharPluginLoader($this->autoloader));
 			$this->pluginManager->registerInterface(new ScriptPluginLoader());
-			$this->pluginManager->registerInterface(new FolderPluginLoader($this->autoloader));
 
 			$providerManager = new WorldProviderManager();
 			if(

src/VersionInfo.php

@@ -31,7 +31,7 @@ use function str_repeat;
 
 final class VersionInfo{
 	public const NAME = "PocketMine-MP";
-	public const BASE_VERSION = "5.33.1";
+	public const BASE_VERSION = "5.33.2";
 	public const IS_DEVELOPMENT_BUILD = true;
 	public const BUILD_CHANNEL = "stable";
 

src/block/AmethystCluster.php

@@ -82,22 +82,22 @@ final class AmethystCluster extends Transparent implements AnyFacing{
 			if($axis === $myAxis){
 				continue;
 			}
-			$box = $box->squashedCopy($axis, $this->stage === self::STAGE_SMALL_BUD ? 4 / 16 : 3 / 16);
+			$box->squash($axis, $this->stage === self::STAGE_SMALL_BUD ? 4 / 16 : 3 / 16);
 		}
-		$box = $box->trimmedCopy($this->facing, 1 - ($this->stage === self::STAGE_CLUSTER ? 7 / 16 : ($this->stage + 3) / 16));
+		$box->trim($this->facing, 1 - ($this->stage === self::STAGE_CLUSTER ? 7 / 16 : ($this->stage + 3) / 16));
 
 		return [$box];
 	}
 
-	private function canBeSupportedAt(Block $block, Facing $facing) : bool{
+	private function canBeSupportedAt(Block $block, int $facing) : bool{
 		return $block->getAdjacentSupportType($facing) === SupportType::FULL;
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if(!$this->canBeSupportedAt($blockReplace, Facing::opposite($face))){
 			return false;
 		}

src/block/Anvil.php

@@ -27,7 +27,6 @@ use pocketmine\block\inventory\AnvilInventory;
 use pocketmine\block\utils\Fallable;
 use pocketmine\block\utils\FallableTrait;
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
@@ -58,7 +57,7 @@ class Anvil extends Transparent implements Fallable, HorizontalFacing{
 	}
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 	}
 
 	public function getDamage() : int{ return $this->damage; }
@@ -73,14 +72,14 @@ class Anvil extends Transparent implements Fallable, HorizontalFacing{
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->squashedCopy(Facing::axis(Facing::rotateY($this->facing->toFacing(), false)), 1 / 8)];
+		return [AxisAlignedBB::one()->squash(Facing::axis(Facing::rotateY($this->facing, false)), 1 / 8)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 			$player->setCurrentWindow(new AnvilInventory($this->position));
 		}
@@ -88,9 +87,9 @@ class Anvil extends Transparent implements Fallable, HorizontalFacing{
 		return true;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player !== null){
-			$this->facing = HorizontalFacingOption::fromFacing(Facing::rotateY($player->getHorizontalFacing(), false));
+			$this->facing = Facing::rotateY($player->getHorizontalFacing(), false);
 		}
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}

src/block/Bamboo.php

@@ -90,10 +90,10 @@ class Bamboo extends Transparent{
 	protected function recalculateCollisionBoxes() : array{
 		//this places the BB at the northwest corner, not the center
 		$inset = 1 - (($this->thick ? 3 : 2) / 16);
-		return [AxisAlignedBB::one()->trimmedCopy(Facing::SOUTH, $inset)->trimmedCopy(Facing::EAST, $inset)];
+		return [AxisAlignedBB::one()->trim(Facing::SOUTH, $inset)->trim(Facing::EAST, $inset)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -138,7 +138,7 @@ class Bamboo extends Transparent{
 		return $top;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($item instanceof Fertilizer){
 			$top = $this->seekToTop();
 			if($top->grow(self::getMaxHeight($top->position->getFloorX(), $top->position->getFloorZ()), mt_rand(1, 2), $player)){

src/block/BambooSapling.php

@@ -61,7 +61,7 @@ final class BambooSapling extends Flowable{
 			$supportBlock->hasTypeTag(BlockTypeTags::SAND);
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($item instanceof Fertilizer || $item instanceof ItemBamboo){
 			if($this->grow($player)){
 				$item->pop();

src/block/Barrel.php

@@ -40,7 +40,7 @@ class Barrel extends Opaque implements AnyFacing{
 	protected bool $open = false;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->facing($this->facing);
 		$w->bool($this->open);
 	}
 
@@ -54,7 +54,7 @@ class Barrel extends Opaque implements AnyFacing{
 		return $this;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player !== null){
 			if(abs($player->getPosition()->x - $this->position->x) < 2 && abs($player->getPosition()->z - $this->position->z) < 2){
 				$y = $player->getEyePos()->y;
@@ -74,7 +74,7 @@ class Barrel extends Opaque implements AnyFacing{
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 			$barrel = $this->position->getWorld()->getTile($this->position);
 			if($barrel instanceof TileBarrel){

src/block/BaseBanner.php

@@ -31,7 +31,6 @@ use pocketmine\block\utils\SupportType;
 use pocketmine\item\Banner as ItemBanner;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
@@ -113,7 +112,7 @@ abstract class BaseBanner extends Transparent implements Colored{
 		return [];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -121,7 +120,7 @@ abstract class BaseBanner extends Transparent implements Colored{
 		return $block->isSolid();
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if(!$this->canBeSupportedBy($blockReplace->getSide($this->getSupportingFace()))){
 			return false;
 		}
@@ -133,7 +132,7 @@ abstract class BaseBanner extends Transparent implements Colored{
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	abstract protected function getSupportingFace() : Facing;
+	abstract protected function getSupportingFace() : int;
 
 	public function onNearbyBlockChange() : void{
 		if(!$this->canBeSupportedBy($this->getSide($this->getSupportingFace()))){

src/block/BaseBigDripleaf.php

@@ -24,7 +24,6 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\event\block\StructureGrowEvent;
@@ -58,13 +57,13 @@ abstract class BaseBigDripleaf extends Transparent implements HorizontalFacing{
 		}
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		$block = $blockReplace->getSide(Facing::DOWN);
 		if(!$this->canBeSupportedBy($block, true)){
 			return false;
 		}
 		if($player !== null){
-			$this->facing = HorizontalFacingOption::fromFacing(Facing::opposite($player->getHorizontalFacing()));
+			$this->facing = Facing::opposite($player->getHorizontalFacing());
 		}
 		if($block instanceof BaseBigDripleaf){
 			$this->facing = $block->facing;
@@ -73,7 +72,7 @@ abstract class BaseBigDripleaf extends Transparent implements HorizontalFacing{
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($item instanceof Fertilizer && $this->grow($player)){
 			$item->pop();
 			return true;
@@ -132,7 +131,7 @@ abstract class BaseBigDripleaf extends Transparent implements HorizontalFacing{
 		return 100;
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 }

src/block/BaseCake.php

@@ -36,7 +36,7 @@ use pocketmine\player\Player;
 abstract class BaseCake extends Transparent implements FoodSource{
 	use StaticSupportTrait;
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -44,7 +44,7 @@ abstract class BaseCake extends Transparent implements FoodSource{
 		return $block->getSide(Facing::DOWN)->getTypeId() !== BlockTypeIds::AIR;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player !== null){
 			return $player->consumeObject($this);
 		}

src/block/BaseCoral.php

@@ -28,7 +28,6 @@ use pocketmine\block\utils\CoralMaterial;
 use pocketmine\block\utils\CoralTypeTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\item\Item;
-use pocketmine\math\Facing;
 use function mt_rand;
 
 abstract class BaseCoral extends Transparent implements CoralMaterial{
@@ -73,7 +72,7 @@ abstract class BaseCoral extends Transparent implements CoralMaterial{
 
 	protected function recalculateCollisionBoxes() : array{ return []; }
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 }

src/block/BaseOminousBanner.php

@@ -28,7 +28,6 @@ use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\SupportType;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
@@ -61,7 +60,7 @@ abstract class BaseOminousBanner extends Transparent{
 		return [];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -69,7 +68,7 @@ abstract class BaseOminousBanner extends Transparent{
 		return $block->isSolid();
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if(!$this->canBeSupportedBy($blockReplace->getSide($this->getSupportingFace()))){
 			return false;
 		}
@@ -77,7 +76,7 @@ abstract class BaseOminousBanner extends Transparent{
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	abstract protected function getSupportingFace() : Facing;
+	abstract protected function getSupportingFace() : int;
 
 	public function onNearbyBlockChange() : void{
 		if(!$this->canBeSupportedBy($this->getSide($this->getSupportingFace()))){

src/block/BaseRail.php

@@ -37,7 +37,7 @@ use function in_array;
 
 abstract class BaseRail extends Flowable{
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($blockReplace->getAdjacentSupportType(Facing::DOWN)->hasEdgeSupport()){
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
@@ -89,9 +89,8 @@ abstract class BaseRail extends Flowable{
 
 		/** @var int $connection */
 		foreach($this->getCurrentShapeConnections() as $connection){
-			$connectionFace = Facing::from($connection & ~RailConnectionInfo::FLAG_ASCEND);
-			$other = $this->getSide($connectionFace);
-			$otherConnection = Facing::opposite($connectionFace)->value;
+			$other = $this->getSide($connection & ~RailConnectionInfo::FLAG_ASCEND);
+			$otherConnection = Facing::opposite($connection & ~RailConnectionInfo::FLAG_ASCEND);
 
 			if(($connection & RailConnectionInfo::FLAG_ASCEND) !== 0){
 				$other = $other->getSide(Facing::UP);
@@ -123,10 +122,10 @@ abstract class BaseRail extends Flowable{
 			case 0:
 				//No constraints, can connect in any direction
 				$possible = [
-					Facing::NORTH->value => true,
-					Facing::SOUTH->value => true,
-					Facing::WEST->value => true,
-					Facing::EAST->value => true
+					Facing::NORTH => true,
+					Facing::SOUTH => true,
+					Facing::WEST => true,
+					Facing::EAST => true
 				];
 				foreach($possible as $p => $_){
 					$possible[$p | RailConnectionInfo::FLAG_ASCEND] = true;
@@ -147,13 +146,13 @@ abstract class BaseRail extends Flowable{
 	 * @phpstan-return array<int, true>
 	 */
 	protected function getPossibleConnectionDirectionsOneConstraint(int $constraint) : array{
-		$opposite = Facing::opposite(Facing::from($constraint & ~RailConnectionInfo::FLAG_ASCEND));
+		$opposite = Facing::opposite($constraint & ~RailConnectionInfo::FLAG_ASCEND);
 
-		$possible = [$opposite->value => true];
+		$possible = [$opposite => true];
 
 		if(($constraint & RailConnectionInfo::FLAG_ASCEND) === 0){
 			//We can slope the other way if this connection isn't already a slope
-			$possible[$opposite->value | RailConnectionInfo::FLAG_ASCEND] = true;
+			$possible[$opposite | RailConnectionInfo::FLAG_ASCEND] = true;
 		}
 
 		return $possible;
@@ -169,10 +168,9 @@ abstract class BaseRail extends Flowable{
 			$continue = false;
 
 			foreach($possible as $thisSide => $_){
-				$thisSideEnum = Facing::from($thisSide & ~RailConnectionInfo::FLAG_ASCEND);
-				$otherSide = Facing::opposite($thisSideEnum)->value;
+				$otherSide = Facing::opposite($thisSide & ~RailConnectionInfo::FLAG_ASCEND);
 
-				$other = $this->getSide($thisSideEnum);
+				$other = $this->getSide($thisSide & ~RailConnectionInfo::FLAG_ASCEND);
 
 				if(($thisSide & RailConnectionInfo::FLAG_ASCEND) !== 0){
 					$other = $other->getSide(Facing::UP);
@@ -214,7 +212,7 @@ abstract class BaseRail extends Flowable{
 	 */
 	private function setConnections(array $connections) : void{
 		if(count($connections) === 1){
-			$connections[] = Facing::opposite(Facing::from($connections[0] & ~RailConnectionInfo::FLAG_ASCEND))->value;
+			$connections[] = Facing::opposite($connections[0] & ~RailConnectionInfo::FLAG_ASCEND);
 		}elseif(count($connections) !== 2){
 			throw new \InvalidArgumentException("Expected exactly 2 connections, got " . count($connections));
 		}
@@ -228,7 +226,7 @@ abstract class BaseRail extends Flowable{
 			$world->useBreakOn($this->position);
 		}else{
 			foreach($this->getCurrentShapeConnections() as $connection){
-				if(($connection & RailConnectionInfo::FLAG_ASCEND) !== 0 && !$this->getSide(Facing::from($connection & ~RailConnectionInfo::FLAG_ASCEND))->getSupportType(Facing::UP)->hasEdgeSupport()){
+				if(($connection & RailConnectionInfo::FLAG_ASCEND) !== 0 && !$this->getSide($connection & ~RailConnectionInfo::FLAG_ASCEND)->getSupportType(Facing::UP)->hasEdgeSupport()){
 					$world->useBreakOn($this->position);
 					break;
 				}

src/block/BaseSign.php

@@ -35,21 +35,25 @@ use pocketmine\event\block\SignChangeEvent;
 use pocketmine\item\Dye;
 use pocketmine\item\Item;
 use pocketmine\item\ItemTypeIds;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\utils\TextFormat;
 use pocketmine\world\BlockTransaction;
 use pocketmine\world\sound\DyeUseSound;
 use pocketmine\world\sound\InkSacUseSound;
+use function abs;
 use function array_map;
 use function assert;
+use function atan2;
+use function fmod;
+use function rad2deg;
 use function strlen;
 
 abstract class BaseSign extends Transparent implements WoodMaterial{
 	use WoodTypeTrait;
 
-	protected SignText $text;
+	protected SignText $text; //TODO: rename this (BC break)
+	protected SignText $backText;
 	private bool $waxed = false;
 
 	protected ?int $editorEntityRuntimeId = null;
@@ -64,6 +68,7 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		$this->woodType = $woodType;
 		parent::__construct($idInfo, $name, $typeInfo);
 		$this->text = new SignText();
+		$this->backText = new SignText();
 		$this->asItemCallback = $asItemCallback;
 	}
 
@@ -72,6 +77,7 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		$tile = $this->position->getWorld()->getTile($this->position);
 		if($tile instanceof TileSign){
 			$this->text = $tile->getText();
+			$this->backText = $tile->getBackText();
 			$this->waxed = $tile->isWaxed();
 			$this->editorEntityRuntimeId = $tile->getEditorEntityRuntimeId();
 		}
@@ -84,6 +90,7 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		$tile = $this->position->getWorld()->getTile($this->position);
 		assert($tile instanceof TileSign);
 		$tile->setText($this->text);
+		$tile->setBackText($this->backText);
 		$tile->setWaxed($this->waxed);
 		$tile->setEditorEntityRuntimeId($this->editorEntityRuntimeId);
 	}
@@ -100,11 +107,11 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		return [];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
-	abstract protected function getSupportingFace() : Facing;
+	abstract protected function getSupportingFace() : int;
 
 	public function onNearbyBlockChange() : void{
 		if($this->getSide($this->getSupportingFace())->getTypeId() === BlockTypeIds::AIR){
@@ -112,7 +119,7 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		}
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player !== null){
 			$this->editorEntityRuntimeId = $player->getId();
 		}
@@ -128,11 +135,11 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		}
 	}
 
-	private function doSignChange(SignText $newText, Player $player, Item $item) : bool{
-		$ev = new SignChangeEvent($this, $player, $newText);
+	private function doSignChange(SignText $newText, Player $player, Item $item, bool $frontFace) : bool{
+		$ev = new SignChangeEvent($this, $player, $newText, $frontFace);
 		$ev->call();
 		if(!$ev->isCancelled()){
-			$this->text = $ev->getNewText();
+			$this->setFaceText($frontFace, $ev->getNewText());
 			$this->position->getWorld()->setBlock($this->position, $this);
 			$item->pop();
 			return true;
@@ -141,8 +148,9 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		return false;
 	}
 
-	private function changeSignGlowingState(bool $glowing, Player $player, Item $item) : bool{
-		if($this->text->isGlowing() !== $glowing && $this->doSignChange(new SignText($this->text->getLines(), $this->text->getBaseColor(), $glowing), $player, $item)){
+	private function changeSignGlowingState(bool $glowing, Player $player, Item $item, bool $frontFace) : bool{
+		$text = $this->getFaceText($frontFace);
+		if($text->isGlowing() !== $glowing && $this->doSignChange(new SignText($text->getLines(), $text->getBaseColor(), $glowing), $player, $item, $frontFace)){
 			$this->position->getWorld()->addSound($this->position, new InkSacUseSound());
 			return true;
 		}
@@ -161,7 +169,7 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		return true;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player === null){
 			return false;
 		}
@@ -169,6 +177,8 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 			return true;
 		}
 
+		$frontFace = $this->interactsFront($this->getHitboxCenter(), $player->getPosition(), $this->getFacingDegrees());
+
 		$dyeColor = $item instanceof Dye ? $item->getColor() : match($item->getTypeId()){
 			ItemTypeIds::BONE_MEAL => DyeColor::WHITE,
 			ItemTypeIds::LAPIS_LAZULI => DyeColor::BLUE,
@@ -177,40 +187,82 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		};
 		if($dyeColor !== null){
 			$color = $dyeColor === DyeColor::BLACK ? new Color(0, 0, 0) : $dyeColor->getRgbValue();
+			$text = $this->getFaceText($frontFace);
 			if(
-				$color->toARGB() !== $this->text->getBaseColor()->toARGB() &&
-				$this->doSignChange(new SignText($this->text->getLines(), $color, $this->text->isGlowing()), $player, $item)
+				$color->toARGB() !== $text->getBaseColor()->toARGB() &&
+				$this->doSignChange(new SignText($text->getLines(), $color, $text->isGlowing()), $player, $item, $frontFace)
 			){
 				$this->position->getWorld()->addSound($this->position, new DyeUseSound());
 				return true;
 			}
 		}elseif(match($item->getTypeId()){
-			ItemTypeIds::INK_SAC => $this->changeSignGlowingState(false, $player, $item),
-			ItemTypeIds::GLOW_INK_SAC => $this->changeSignGlowingState(true, $player, $item),
+			ItemTypeIds::INK_SAC => $this->changeSignGlowingState(false, $player, $item, $frontFace),
+			ItemTypeIds::GLOW_INK_SAC => $this->changeSignGlowingState(true, $player, $item, $frontFace),
 			ItemTypeIds::HONEYCOMB => $this->wax($player, $item),
 			default => false
 		}){
 			return true;
 		}
 
-		$player->openSignEditor($this->position);
+		$player->openSignEditor($this->position, $frontFace);
 
 		return true;
 	}
 
+	private function interactsFront(Vector3 $hitboxCenter, Vector3 $playerPosition, float $signFacingDegrees) : bool{
+		$playerCenterDiffX = $playerPosition->x - $hitboxCenter->x;
+		$playerCenterDiffZ = $playerPosition->z - $hitboxCenter->z;
+
+		$f1 = rad2deg(atan2($playerCenterDiffZ, $playerCenterDiffX)) - 90.0;
+
+		$rotationDiff = $signFacingDegrees - $f1;
+		$rotation = fmod($rotationDiff + 180.0, 360.0) - 180.0; // Normalize to [-180, 180]
+		return abs($rotation) <= 90.0;
+	}
+
+	/**
+	 * Returns the center of the sign's hitbox. Used to decide which face of the sign to open when a player interacts.
+	 */
+	protected function getHitboxCenter() : Vector3{
+		return $this->position->add(0.5, 0.5, 0.5);
+	}
+
+	/**
+	 * TODO: make this abstract (BC break)
+	 */
+	protected function getFacingDegrees() : float{
+		return 0;
+	}
+
 	/**
 	 * Returns an object containing information about the sign text.
+	 * @deprecated
+	 * @see self::getFaceText()
 	 */
 	public function getText() : SignText{
 		return $this->text;
 	}
 
-	/** @return $this */
+	/**
+	 * @deprecated
+	 * @see self::setFaceText()
+	 * @return $this
+	 */
 	public function setText(SignText $text) : self{
 		$this->text = $text;
 		return $this;
 	}
 
+	public function getFaceText(bool $frontFace) : SignText{
+		return $frontFace ? $this->text : $this->backText;
+	}
+
+	/** @return $this */
+	public function setFaceText(bool $frontFace, SignText $text) : self{
+		$frontFace ? $this->text = $text : $this->backText = $text;
+		return $this;
+	}
+
 	/**
 	 * Returns whether the sign has been waxed using a honeycomb. If true, the sign cannot be edited by a player.
 	 */
@@ -235,13 +287,21 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		return $this;
 	}
 
+	/**
+	 * @deprecated
+	 * @see self::updateFaceText()
+	 */
+	public function updateText(Player $author, SignText $text) : bool{
+		return $this->updateFaceText($author, true, $text);
+	}
+
 	/**
 	 * Called by the player controller (network session) to update the sign text, firing events as appropriate.
 	 *
 	 * @return bool if the sign update was successful.
 	 * @throws \UnexpectedValueException if the text payload is too large
 	 */
-	public function updateText(Player $author, SignText $text) : bool{
+	public function updateFaceText(Player $author, bool $frontFace, SignText $text) : bool{
 		$size = 0;
 		foreach($text->getLines() as $line){
 			$size += strlen($line);
@@ -249,15 +309,16 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		if($size > 1000){
 			throw new \UnexpectedValueException($author->getName() . " tried to write $size bytes of text onto a sign (bigger than max 1000)");
 		}
+		$oldText = $this->getFaceText($frontFace);
 		$ev = new SignChangeEvent($this, $author, new SignText(array_map(function(string $line) : string{
 			return TextFormat::clean($line, false);
-		}, $text->getLines()), $this->text->getBaseColor(), $this->text->isGlowing()));
+		}, $text->getLines()), $oldText->getBaseColor(), $oldText->isGlowing()), $frontFace);
 		if($this->waxed || $this->editorEntityRuntimeId !== $author->getId()){
 			$ev->cancel();
 		}
 		$ev->call();
 		if(!$ev->isCancelled()){
-			$this->setText($ev->getNewText());
+			$this->setFaceText($frontFace, $ev->getNewText());
 			$this->setEditorEntityRuntimeId(null);
 			$this->position->getWorld()->setBlock($this->position, $this);
 			return true;

src/block/Bed.php

@@ -28,7 +28,6 @@ use pocketmine\block\utils\Colored;
 use pocketmine\block\utils\ColoredTrait;
 use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
@@ -52,7 +51,7 @@ class Bed extends Transparent implements Colored, HorizontalFacing{
 	protected bool $head = false;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 		$w->bool($this->occupied);
 		$w->bool($this->head);
 	}
@@ -80,10 +79,10 @@ class Bed extends Transparent implements Colored, HorizontalFacing{
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->trimmedCopy(Facing::UP, 7 / 16)];
+		return [AxisAlignedBB::one()->trim(Facing::UP, 7 / 16)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -107,8 +106,8 @@ class Bed extends Transparent implements Colored, HorizontalFacing{
 		return $this;
 	}
 
-	private function getOtherHalfSide() : Facing{
-		return $this->head ? Facing::opposite($this->facing->toFacing()) : $this->facing->toFacing();
+	private function getOtherHalfSide() : int{
+		return $this->head ? Facing::opposite($this->facing) : $this->facing;
 	}
 
 	public function getOtherHalf() : ?Bed{
@@ -120,7 +119,7 @@ class Bed extends Transparent implements Colored, HorizontalFacing{
 		return null;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player !== null){
 			$other = $this->getOtherHalf();
 			$playerPos = $player->getPosition();
@@ -173,11 +172,9 @@ class Bed extends Transparent implements Colored, HorizontalFacing{
 		return $entity->getMotion()->y * -3 / 4; // 2/3 in Java, according to the wiki
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($this->canBeSupportedAt($blockReplace)){
-			if($player !== null){
-				$this->facing = HorizontalFacingOption::fromFacing($player->getHorizontalFacing());
-			}
+			$this->facing = $player !== null ? $player->getHorizontalFacing() : Facing::NORTH;
 
 			$next = $this->getSide($this->getOtherHalfSide());
 			if($next->canBeReplaced() && $this->canBeSupportedAt($next)){

src/block/Bell.php

@@ -26,7 +26,6 @@ namespace pocketmine\block;
 use pocketmine\block\tile\Bell as TileBell;
 use pocketmine\block\utils\BellAttachmentType;
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
@@ -47,33 +46,32 @@ final class Bell extends Transparent implements HorizontalFacing{
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
 		$w->enum($this->attachmentType);
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		$realFacing = $this->facing->toFacing();
 		if($this->attachmentType === BellAttachmentType::FLOOR){
 			return [
-				AxisAlignedBB::one()->squashedCopy(Facing::axis($realFacing), 1 / 4)->trimmedCopy(Facing::UP, 3 / 16)
+				AxisAlignedBB::one()->squash(Facing::axis($this->facing), 1 / 4)->trim(Facing::UP, 3 / 16)
 			];
 		}
 		if($this->attachmentType === BellAttachmentType::CEILING){
 			return [
-				AxisAlignedBB::one()->contractedCopy(1 / 4, 0, 1 / 4)->trimmedCopy(Facing::DOWN, 1 / 4)
+				AxisAlignedBB::one()->contract(1 / 4, 0, 1 / 4)->trim(Facing::DOWN, 1 / 4)
 			];
 		}
 
 		$box = AxisAlignedBB::one()
-			->squashedCopy(Facing::axis(Facing::rotateY($realFacing, true)), 1 / 4)
-			->trimmedCopy(Facing::UP, 1 / 16)
-			->trimmedCopy(Facing::DOWN, 1 / 4);
+			->squash(Facing::axis(Facing::rotateY($this->facing, true)), 1 / 4)
+			->trim(Facing::UP, 1 / 16)
+			->trim(Facing::DOWN, 1 / 4);
 
 		return [
-			$this->attachmentType === BellAttachmentType::ONE_WALL ? $box->trimmedCopy($realFacing, 3 / 16) : $box
+			$this->attachmentType === BellAttachmentType::ONE_WALL ? $box->trim($this->facing, 3 / 16) : $box
 		];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -85,23 +83,23 @@ final class Bell extends Transparent implements HorizontalFacing{
 		return $this;
 	}
 
-	private function canBeSupportedAt(Block $block, Facing $face) : bool{
+	private function canBeSupportedAt(Block $block, int $face) : bool{
 		return $block->getAdjacentSupportType($face) !== SupportType::NONE;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if(!$this->canBeSupportedAt($blockReplace, Facing::opposite($face))){
 			return false;
 		}
 		if($face === Facing::UP){
 			if($player !== null){
-				$this->setFacing(HorizontalFacingOption::fromFacing(Facing::opposite($player->getHorizontalFacing())));
+				$this->setFacing(Facing::opposite($player->getHorizontalFacing()));
 			}
 			$this->setAttachmentType(BellAttachmentType::FLOOR);
 		}elseif($face === Facing::DOWN){
 			$this->setAttachmentType(BellAttachmentType::CEILING);
 		}else{
-			$this->setFacing(HorizontalFacingOption::fromFacing($face));
+			$this->setFacing($face);
 			$this->setAttachmentType(
 				$this->canBeSupportedAt($blockReplace, $face) ?
 					BellAttachmentType::TWO_WALLS :
@@ -115,8 +113,8 @@ final class Bell extends Transparent implements HorizontalFacing{
 		foreach(match($this->attachmentType){
 			BellAttachmentType::CEILING => [Facing::UP],
 			BellAttachmentType::FLOOR => [Facing::DOWN],
-			BellAttachmentType::ONE_WALL => [Facing::opposite($this->facing->toFacing())],
-			BellAttachmentType::TWO_WALLS => [$this->facing->toFacing(), Facing::opposite($this->facing->toFacing())]
+			BellAttachmentType::ONE_WALL => [Facing::opposite($this->facing)],
+			BellAttachmentType::TWO_WALLS => [$this->facing, Facing::opposite($this->facing)]
 		} as $supportBlockDirection){
 			if(!$this->canBeSupportedAt($this, $supportBlockDirection)){
 				$this->position->getWorld()->useBreakOn($this->position);
@@ -125,7 +123,7 @@ final class Bell extends Transparent implements HorizontalFacing{
 		}
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player !== null){
 			$faceHit = Facing::opposite($player->getHorizontalFacing());
 			if($this->isValidFaceToRing($faceHit)){
@@ -144,7 +142,7 @@ final class Bell extends Transparent implements HorizontalFacing{
 		}
 	}
 
-	public function ring(Facing $faceHit) : void{
+	public function ring(int $faceHit) : void{
 		$world = $this->position->getWorld();
 		$world->addSound($this->position, new BellRingSound());
 		$tile = $world->getTile($this->position);
@@ -157,11 +155,11 @@ final class Bell extends Transparent implements HorizontalFacing{
 		return [$this->asItem()];
 	}
 
-	private function isValidFaceToRing(Facing $faceHit) : bool{
+	private function isValidFaceToRing(int $faceHit) : bool{
 		return match($this->attachmentType){
 			BellAttachmentType::CEILING => true,
-			BellAttachmentType::FLOOR => Facing::axis($faceHit) === Facing::axis($this->facing->toFacing()),
-			BellAttachmentType::ONE_WALL, BellAttachmentType::TWO_WALLS => $faceHit === Facing::rotateY($this->facing->toFacing(), false) || $faceHit === Facing::rotateY($this->facing->toFacing(), true),
+			BellAttachmentType::FLOOR => Facing::axis($faceHit) === Facing::axis($this->facing),
+			BellAttachmentType::ONE_WALL, BellAttachmentType::TWO_WALLS => $faceHit === Facing::rotateY($this->facing, false) || $faceHit === Facing::rotateY($this->facing, true),
 		};
 	}
 }

src/block/BigDripleafHead.php

@@ -80,8 +80,8 @@ class BigDripleafHead extends BaseBigDripleaf{
 		if(!$entity instanceof Projectile && $this->leafState === DripleafState::STABLE){
 			//the entity must be standing on top of the leaf - do not collapse if the entity is standing underneath
 			$intersection = AxisAlignedBB::one()
-				->offsetCopy($this->position->x, $this->position->y, $this->position->z)
-				->trimmedCopy(Facing::DOWN, 1 - $this->getLeafTopOffset());
+				->offset($this->position->x, $this->position->y, $this->position->z)
+				->trim(Facing::DOWN, 1 - $this->getLeafTopOffset());
 			if($entity->getBoundingBox()->intersectsWith($intersection)){
 				$this->setTiltAndScheduleTick(DripleafState::UNSTABLE);
 				return false;
@@ -116,8 +116,8 @@ class BigDripleafHead extends BaseBigDripleaf{
 		if($this->leafState !== DripleafState::FULL_TILT){
 			return [
 				AxisAlignedBB::one()
-					->trimmedCopy(Facing::DOWN, 11 / 16)
-					->trimmedCopy(Facing::UP, $this->getLeafTopOffset())
+					->trim(Facing::DOWN, 11 / 16)
+					->trim(Facing::UP, $this->getLeafTopOffset())
 			];
 		}
 		return [];

src/block/Block.php

@@ -26,6 +26,8 @@ declare(strict_types=1);
  */
 namespace pocketmine\block;
 
+use pmmp\encoding\BE;
+use pmmp\encoding\LE;
 use pocketmine\block\tile\Spawnable;
 use pocketmine\block\tile\Tile;
 use pocketmine\block\utils\SupportType;
@@ -49,7 +51,6 @@ use pocketmine\math\Vector3;
 use pocketmine\nbt\tag\CompoundTag;
 use pocketmine\player\Player;
 use pocketmine\utils\AssumptionFailedError;
-use pocketmine\utils\Binary;
 use pocketmine\world\BlockTransaction;
 use pocketmine\world\format\Chunk;
 use pocketmine\world\Position;
@@ -65,10 +66,10 @@ class Block{
 
 	/**
 	 * @internal
-	 * Hardcoded int is `Binary::readLong(hash('xxh3', Binary::writeLLong(BlockTypeIds::AIR_TYPE_NUMBER), binary: true))`
+	 * Hardcoded int is `Binary::readLong(hash('xxh3', Binary::writeLLong(BlockTypeIds::AIR), binary: true))`
 	 * TODO: it would be much easier if we could just make this 0 or some other easy value
 	 */
-	public const EMPTY_STATE_ID = (BlockIdentifier::AIR_TYPE_NUMBER << self::INTERNAL_STATE_DATA_BITS) | (-7482769108513497636 & self::INTERNAL_STATE_DATA_MASK);
+	public const EMPTY_STATE_ID = (BlockTypeIds::AIR << self::INTERNAL_STATE_DATA_BITS) | (-7482769108513497636 & self::INTERNAL_STATE_DATA_MASK);
 
 	protected BlockIdentifier $idInfo;
 	protected string $fallbackName;
@@ -97,10 +98,11 @@ class Block{
 	 * The type ID is included in the XOR mask. This is not necessary to improve distribution, but it reduces the number
 	 * of operations required to compute the state ID (micro optimization).
 	 */
-	public static function computeStateIdXorMask(int $typeId) : int{
+	private static function computeStateIdXorMask(int $typeId) : int{
+		//TODO: the mixed byte order here is probably a mistake, but it doesn't break anything for now
 		return
 			$typeId << self::INTERNAL_STATE_DATA_BITS |
-			(Binary::readLong(hash('xxh3', Binary::writeLLong($typeId), binary: true)) & self::INTERNAL_STATE_DATA_MASK);
+			(BE::unpackSignedLong(hash('xxh3', LE::packSignedLong($typeId), binary: true)) & self::INTERNAL_STATE_DATA_MASK);
 	}
 
 	/**
@@ -120,7 +122,7 @@ class Block{
 		$this->describeBlockOnlyState($calculator);
 		$this->requiredBlockOnlyStateDataBits = $calculator->getBitsUsed();
 
-		$this->stateIdXorMask = self::computeStateIdXorMask($idInfo->getBlockTypeNumber());
+		$this->stateIdXorMask = self::computeStateIdXorMask($idInfo->getBlockTypeId());
 
 		//this must be done last, otherwise the defaultState could have uninitialized fields
 		$defaultState = clone $this;
@@ -156,7 +158,7 @@ class Block{
 	 *
 	 * @see BlockTypeIds
 	 */
-	public function getTypeId() : string{
+	public function getTypeId() : int{
 		return $this->idInfo->getBlockTypeId();
 	}
 
@@ -424,7 +426,7 @@ class Block{
 	 * Returns whether this block can replace the given block in the given placement conditions.
 	 * This is used to allow slabs of the same type to combine into double slabs.
 	 */
-	public function canBePlacedAt(Block $blockReplace, Vector3 $clickVector, Facing $face, bool $isClickedBlock) : bool{
+	public function canBePlacedAt(Block $blockReplace, Vector3 $clickVector, int $face, bool $isClickedBlock) : bool{
 		return $blockReplace->canBeReplaced();
 	}
 
@@ -436,13 +438,13 @@ class Block{
 	 * @param Item             $item         Item used to place the block
 	 * @param Block            $blockReplace Block expected to be replaced
 	 * @param Block            $blockClicked Block that was clicked using the item
-	 * @param Facing           $face         Face of the clicked block which was clicked
+	 * @param int              $face         Face of the clicked block which was clicked
 	 * @param Vector3          $clickVector  Exact position inside the clicked block where the click occurred, relative to the block's position
 	 * @param Player|null      $player       Player who placed the block, or null if it was not a player
 	 *
 	 * @return bool whether the placement should go ahead
 	 */
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		$tx->addBlock($blockReplace->position, $this);
 		return true;
 	}
@@ -524,7 +526,7 @@ class Block{
 	 * @param Vector3 $clickVector    Exact position where the click occurred, relative to the block's integer position
 	 * @param Item[]  &$returnedItems Items to be added to the target's inventory (or dropped, if the inventory is full)
 	 */
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		return false;
 	}
 
@@ -533,7 +535,7 @@ class Block{
 	 *
 	 * @return bool if an action took place, prevents starting to break the block if true.
 	 */
-	public function onAttack(Item $item, Facing $face, ?Player $player = null) : bool{
+	public function onAttack(Item $item, int $face, ?Player $player = null) : bool{
 		return false;
 	}
 
@@ -770,10 +772,10 @@ class Block{
 	 *
 	 * @return Block
 	 */
-	public function getSide(Facing $side, int $step = 1){
+	public function getSide(int $side, int $step = 1){
 		$position = $this->position;
 		if($position->isValid()){
-			[$dx, $dy, $dz] = Facing::OFFSET[$side->value] ?? [0, 0, 0];
+			[$dx, $dy, $dz] = Facing::OFFSET[$side] ?? [0, 0, 0];
 			return $position->getWorld()->getBlockAt(
 				$position->x + ($dx * $step),
 				$position->y + ($dy * $step),
@@ -793,7 +795,7 @@ class Block{
 	public function getHorizontalSides() : \Generator{
 		$world = $this->position->getWorld();
 		foreach(Facing::HORIZONTAL as $facing){
-			[$dx, $dy, $dz] = Facing::OFFSET[$facing->value];
+			[$dx, $dy, $dz] = Facing::OFFSET[$facing];
 			//TODO: yield Facing as the key?
 			yield $world->getBlockAt(
 				$this->position->x + $dx,
@@ -914,12 +916,11 @@ class Block{
 	 */
 	final public function getCollisionBoxes() : array{
 		if($this->collisionBoxes === null){
-			$collisionBoxes = $this->recalculateCollisionBoxes();
+			$this->collisionBoxes = $this->recalculateCollisionBoxes();
 			$extraOffset = $this->getModelPositionOffset();
 			$offset = $extraOffset !== null ? $this->position->addVector($extraOffset) : $this->position;
-			$this->collisionBoxes = [];
-			foreach($collisionBoxes as $bb){
-				$this->collisionBoxes[] = $bb->offsetCopy($offset->x, $offset->y, $offset->z);
+			foreach($this->collisionBoxes as $bb){
+				$bb->offset($offset->x, $offset->y, $offset->z);
 			}
 		}
 
@@ -946,11 +947,11 @@ class Block{
 	 * Returns the type of support that the block can provide on the given face. This is used to determine whether
 	 * blocks placed on the given face can be supported by this block.
 	 */
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::FULL;
 	}
 
-	protected function getAdjacentSupportType(Facing $facing) : SupportType{
+	protected function getAdjacentSupportType(int $facing) : SupportType{
 		return $this->getSide($facing)->getSupportType(Facing::opposite($facing));
 	}
 

src/block/BlockIdentifier.php

@@ -27,27 +27,22 @@ use pocketmine\block\tile\Tile;
 use pocketmine\utils\Utils;
 
 class BlockIdentifier{
-	private int $typeNumber;
-
 	/**
 	 * @phpstan-param class-string<Tile>|null $tileClass
 	 */
 	public function __construct(
-		private string $blockTypeId,
+		private int $blockTypeId,
 		private ?string $tileClass = null
 	){
-		$this->typeNumber = self::lookupTypeNumberFromTypeId($this->blockTypeId);
+		if($blockTypeId < 0){
+			throw new \InvalidArgumentException("Block type ID may not be negative");
+		}
 		if($tileClass !== null){
 			Utils::testValidInstance($tileClass, Tile::class);
 		}
 	}
 
-	public function getBlockTypeId() : string{ return $this->blockTypeId; }
-
-	/**
-	 * @internal
-	 */
-	public function getBlockTypeNumber() : int{ return $this->typeNumber; }
+	public function getBlockTypeId() : int{ return $this->blockTypeId; }
 
 	/**
 	 * @phpstan-return class-string<Tile>|null
@@ -55,52 +50,4 @@ class BlockIdentifier{
 	public function getTileClass() : ?string{
 		return $this->tileClass;
 	}
-
-	public const AIR_TYPE_NUMBER = 10000;
-
-	private static int $nextTypeNumber = self::AIR_TYPE_NUMBER + 1; //fixed ID reserved for air, for Block::EMPTY_STATE_ID
-
-	/**
-	 * @var int[]
-	 * @phpstan-var array<string, int>
-	 */
-	private static $typeIdToTypeNumber = [];
-	/**
-	 * @var string[]
-	 * @phpstan-var array<int, string>
-	 */
-	private static $typeNumberToTypeId = [];
-
-	/**
-	 * @var int[]
-	 * @phpstan-var array<int, int>
-	 */
-	private static $typeIdXorMasks = [];
-
-	public static function firstUnusedTypeNumber() : int{
-		return self::$nextTypeNumber;
-	}
-
-	private static function claimTypeId(string $typeId) : int{
-		if(isset(self::$typeIdToTypeNumber[$typeId])){
-			throw new \InvalidArgumentException("Type ID \"$typeId\" has already been claimed");
-		}
-		$typeNumber = $typeId === BlockTypeIds::AIR ? self::AIR_TYPE_NUMBER : self::$nextTypeNumber++;
-		self::$typeIdToTypeNumber[$typeId] = $typeNumber;
-		self::$typeNumberToTypeId[$typeNumber] = $typeId;
-		self::$typeIdXorMasks[$typeNumber] = Block::computeStateIdXorMask($typeNumber);
-		return $typeNumber;
-	}
-
-	public static function lookupTypeNumberFromTypeId(string $typeId) : int{
-		return self::$typeIdToTypeNumber[$typeId] ??= self::claimTypeId($typeId);
-	}
-
-	public static function stateIdXorMask(int $typeId) : int{
-		return self::$typeIdXorMasks[$typeId];
-	}
-
-	public static function lookupTypeIdFromTypeNumber(int $typeNumber) : string{
-		return self::$typeNumberToTypeId[$typeNumber] ?? throw new \InvalidArgumentException("Unknown type number $typeNumber (probably not registered on this thread?)");
-	}
 }

src/block/BrewingStand.php

@@ -51,17 +51,17 @@ class BrewingStand extends Transparent{
 	protected function recalculateCollisionBoxes() : array{
 		return [
 			//bottom slab part - in PC this is also inset on X/Z by 1/16, but Bedrock sucks
-			AxisAlignedBB::one()->trimmedCopy(Facing::UP, 7 / 8),
+			AxisAlignedBB::one()->trim(Facing::UP, 7 / 8),
 
 			//center post
 			AxisAlignedBB::one()
-				->squashedCopy(Axis::X, 7 / 16)
-				->squashedCopy(Axis::Z, 7 / 16)
-				->trimmedCopy(Facing::UP, 1 / 8)
+				->squash(Axis::X, 7 / 16)
+				->squash(Axis::Z, 7 / 16)
+				->trim(Facing::UP, 1 / 8)
 		];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -95,7 +95,7 @@ class BrewingStand extends Transparent{
 		return $this;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 			$stand = $this->position->getWorld()->getTile($this->position);
 			if($stand instanceof TileBrewingStand && $stand->canOpenWith($item->getCustomName())){

src/block/Button.php

@@ -40,7 +40,7 @@ abstract class Button extends Flowable implements AnyFacing{
 	protected bool $pressed = false;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->facing($this->facing);
 		$w->bool($this->pressed);
 	}
 
@@ -52,7 +52,7 @@ abstract class Button extends Flowable implements AnyFacing{
 		return $this;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($this->canBeSupportedAt($blockReplace, $face)){
 			$this->facing = $face;
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
@@ -62,7 +62,7 @@ abstract class Button extends Flowable implements AnyFacing{
 
 	abstract protected function getActivationTime() : int;
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if(!$this->pressed){
 			$this->pressed = true;
 			$world = $this->position->getWorld();
@@ -89,7 +89,7 @@ abstract class Button extends Flowable implements AnyFacing{
 		}
 	}
 
-	private function canBeSupportedAt(Block $block, Facing $face) : bool{
+	private function canBeSupportedAt(Block $block, int $face) : bool{
 		return $block->getAdjacentSupportType(Facing::opposite($face))->hasCenterSupport();
 	}
 }

src/block/Cactus.php

@@ -46,10 +46,10 @@ class Cactus extends Transparent implements Ageable{
 
 	protected function recalculateCollisionBoxes() : array{
 		$shrinkSize = 1 / 16;
-		return [AxisAlignedBB::one()->contractedCopy($shrinkSize, 0, $shrinkSize)->trimmedCopy(Facing::UP, $shrinkSize)];
+		return [AxisAlignedBB::one()->contract($shrinkSize, 0, $shrinkSize)->trim(Facing::UP, $shrinkSize)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 

src/block/Cake.php

@@ -43,9 +43,9 @@ class Cake extends BaseCake{
 	protected function recalculateCollisionBoxes() : array{
 		return [
 			AxisAlignedBB::one()
-				->contractedCopy(1 / 16, 0, 1 / 16)
-				->trimmedCopy(Facing::UP, 0.5)
-				->trimmedCopy(Facing::WEST, $this->bites / 8)
+				->contract(1 / 16, 0, 1 / 16)
+				->trim(Facing::UP, 0.5)
+				->trim(Facing::WEST, $this->bites / 8)
 		];
 	}
 
@@ -60,7 +60,7 @@ class Cake extends BaseCake{
 		return $this;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($this->bites === 0 && $item instanceof ItemBlock){
 			$block = $item->getBlock();
 			$resultBlock = null;

src/block/CakeWithCandle.php

@@ -40,8 +40,8 @@ class CakeWithCandle extends BaseCake implements Lightable{
 	protected function recalculateCollisionBoxes() : array{
 		return [
 			AxisAlignedBB::one()
-				->contractedCopy(1 / 16, 0, 1 / 16)
-				->trimmedCopy(Facing::UP, 0.5) //TODO: not sure if the candle affects height
+				->contract(1 / 16, 0, 1 / 16)
+				->trim(Facing::UP, 0.5) //TODO: not sure if the candle affects height
 		];
 	}
 
@@ -49,7 +49,7 @@ class CakeWithCandle extends BaseCake implements Lightable{
 		return VanillaBlocks::CANDLE();
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($this->lit && $face !== Facing::UP){
 			return true;
 		}

src/block/Campfire.php

@@ -26,7 +26,6 @@ namespace pocketmine\block;
 use pocketmine\block\inventory\CampfireInventory;
 use pocketmine\block\tile\Campfire as TileCampfire;
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\Lightable;
 use pocketmine\block\utils\LightableTrait;
@@ -128,12 +127,12 @@ class Campfire extends Transparent implements Lightable, HorizontalFacing{
 		];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->trimmedCopy(Facing::UP, 9 / 16)];
+		return [AxisAlignedBB::one()->trim(Facing::UP, 9 / 16)];
 	}
 
 	/**
@@ -172,18 +171,18 @@ class Campfire extends Transparent implements Lightable, HorizontalFacing{
 		return $this->cookingTimes[$slot] ?? 0;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($this->getSide(Facing::DOWN) instanceof Campfire){
 			return false;
 		}
 		if($player !== null){
-			$this->facing = HorizontalFacingOption::fromFacing($player->getHorizontalFacing());
+			$this->facing = $player->getHorizontalFacing();
 		}
 		$this->lit = true;
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if(!$this->lit){
 			if($item->getTypeId() === ItemTypeIds::FIRE_CHARGE){
 				$item->pop();

src/block/Candle.php

@@ -71,27 +71,27 @@ class Candle extends Transparent implements Lightable{
 		return [
 			(match($this->count){
 				1 => AxisAlignedBB::one()
-					->squashedCopy(Axis::X, 7 / 16)
-					->squashedCopy(Axis::Z, 7 / 16),
+					->squash(Axis::X, 7 / 16)
+					->squash(Axis::Z, 7 / 16),
 				2 => AxisAlignedBB::one()
-					->squashedCopy(Axis::X, 5 / 16)
-					->trimmedCopy(Facing::NORTH, 7 / 16) //0.3 thick on the Z axis
-					->trimmedCopy(Facing::SOUTH, 6 / 16),
+					->squash(Axis::X, 5 / 16)
+					->trim(Facing::NORTH, 7 / 16) //0.3 thick on the Z axis
+					->trim(Facing::SOUTH, 6 / 16),
 				3 => AxisAlignedBB::one()
-					->trimmedCopy(Facing::WEST, 5 / 16)
-					->trimmedCopy(Facing::EAST, 6 / 16)
-					->trimmedCopy(Facing::NORTH, 6 / 16)
-					->trimmedCopy(Facing::SOUTH, 5 / 16),
+					->trim(Facing::WEST, 5 / 16)
+					->trim(Facing::EAST, 6 / 16)
+					->trim(Facing::NORTH, 6 / 16)
+					->trim(Facing::SOUTH, 5 / 16),
 				4 => AxisAlignedBB::one()
-					->squashedCopy(Axis::X, 5 / 16)
-					->trimmedCopy(Facing::NORTH, 5 / 16)
-					->trimmedCopy(Facing::SOUTH, 6 / 16),
+					->squash(Axis::X, 5 / 16)
+					->trim(Facing::NORTH, 5 / 16)
+					->trim(Facing::SOUTH, 6 / 16),
 				default => throw new AssumptionFailedError("Unreachable")
-			})->trimmedCopy(Facing::UP, 10 / 16)
+			})->trim(Facing::UP, 10 / 16)
 		];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -99,12 +99,12 @@ class Candle extends Transparent implements Lightable{
 		return $block instanceof Candle && $block->hasSameTypeId($this) ? $block : null;
 	}
 
-	public function canBePlacedAt(Block $blockReplace, Vector3 $clickVector, Facing $face, bool $isClickedBlock) : bool{
+	public function canBePlacedAt(Block $blockReplace, Vector3 $clickVector, int $face, bool $isClickedBlock) : bool{
 		$candle = $this->getCandleIfCompatibleType($blockReplace);
 		return $candle !== null ? $candle->count < self::MAX_COUNT : parent::canBePlacedAt($blockReplace, $clickVector, $face, $isClickedBlock);
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if(!$blockReplace->getAdjacentSupportType(Facing::DOWN)->hasCenterSupport()){
 			return false;
 		}

src/block/Carpet.php

@@ -38,7 +38,7 @@ class Carpet extends Flowable implements Colored{
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->trimmedCopy(Facing::UP, 15 / 16)];
+		return [AxisAlignedBB::one()->trim(Facing::UP, 15 / 16)];
 	}
 
 	private function canBeSupportedAt(Block $block) : bool{

src/block/CartographyTable.php

@@ -25,13 +25,12 @@ namespace pocketmine\block;
 
 use pocketmine\block\inventory\CartographyTableInventory;
 use pocketmine\item\Item;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 
 final class CartographyTable extends Opaque{
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player !== null){
 			$player->setCurrentWindow(new CartographyTableInventory($this->position));
 		}

src/block/Cauldron.php

@@ -51,16 +51,16 @@ final class Cauldron extends Transparent{
 
 	protected function recalculateCollisionBoxes() : array{
 		$result = [
-			AxisAlignedBB::one()->trimmedCopy(Facing::UP, 11 / 16) //bottom of the cauldron
+			AxisAlignedBB::one()->trim(Facing::UP, 11 / 16) //bottom of the cauldron
 		];
 
 		foreach(Facing::HORIZONTAL as $f){ //add the frame parts around the bowl
-			$result[] = AxisAlignedBB::one()->trimmedCopy($f, 14 / 16);
+			$result[] = AxisAlignedBB::one()->trim($f, 14 / 16);
 		}
 		return $result;
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return $facing === Facing::UP ? SupportType::EDGE : SupportType::NONE;
 	}
 
@@ -75,7 +75,7 @@ final class Cauldron extends Transparent{
 		$returnedItems[] = $returnedItem;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($item->getTypeId() === ItemTypeIds::WATER_BUCKET){
 			$this->fill(FillableCauldron::MAX_FILL_LEVEL, VanillaBlocks::WATER_CAULDRON(), $item, VanillaItems::BUCKET(), $returnedItems);
 		}elseif($item->getTypeId() === ItemTypeIds::LAVA_BUCKET){

src/block/CaveVines.php

@@ -84,12 +84,12 @@ class CaveVines extends Flowable implements Ageable{
 		return $supportBlock->getSupportType(Facing::DOWN) === SupportType::FULL || $supportBlock->hasSameTypeId($this);
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		$this->age = mt_rand(0, self::MAX_AGE);
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($this->berries){
 			$this->position->getWorld()->dropItem($this->position, $this->asItem());
 			$this->position->getWorld()->addSound($this->position, new GlowBerriesPickSound());
@@ -159,7 +159,7 @@ class CaveVines extends Flowable implements Ageable{
 		return VanillaItems::GLOW_BERRIES();
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 }

src/block/CeilingCenterHangingSign.php

@@ -36,12 +36,12 @@ final class CeilingCenterHangingSign extends BaseSign implements SignLikeRotatio
 	use SignLikeRotationTrait;
 	use StaticSupportTrait;
 
-	protected function getSupportingFace() : Facing{
+	protected function getSupportingFace() : int{
 		return Facing::UP;
 	}
 
 	//TODO: duplicated code :(
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($face !== Facing::DOWN){
 			return false;
 		}
@@ -58,4 +58,8 @@ final class CeilingCenterHangingSign extends BaseSign implements SignLikeRotatio
 			$supportBlock->getSupportType(Facing::DOWN)->hasCenterSupport() ||
 			$supportBlock->hasTypeTag(BlockTypeTags::HANGING_SIGN);
 	}
+
+	protected function getFacingDegrees() : float{
+		return $this->rotation * 22.5;
+	}
 }

src/block/CeilingEdgesHangingSign.php

@@ -24,28 +24,28 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\item\Item;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
+use pocketmine\utils\AssumptionFailedError;
 use pocketmine\world\BlockTransaction;
 
 final class CeilingEdgesHangingSign extends BaseSign implements HorizontalFacing{
 	use HorizontalFacingTrait;
 
-	protected function getSupportingFace() : Facing{
+	protected function getSupportingFace() : int{
 		return Facing::UP;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($face !== Facing::DOWN){
 			return false;
 		}
 		if($player !== null){
-			$this->facing = HorizontalFacingOption::fromFacing(Facing::opposite($player->getHorizontalFacing()));
+			$this->facing = Facing::opposite($player->getHorizontalFacing());
 		}
 		if(!$this->canBeSupportedAt($blockReplace)){
 			return false;
@@ -64,6 +64,16 @@ final class CeilingEdgesHangingSign extends BaseSign implements HorizontalFacing
 		$supportBlock = $block->getSide(Facing::UP);
 		return
 			$supportBlock->getSupportType(Facing::DOWN) === SupportType::FULL ||
-			(($supportBlock instanceof WallHangingSign || $supportBlock instanceof CeilingEdgesHangingSign) && Facing::axis($supportBlock->getFacing()->toFacing()) === Facing::axis($this->facing->toFacing()));
+			(($supportBlock instanceof WallHangingSign || $supportBlock instanceof CeilingEdgesHangingSign) && Facing::axis($supportBlock->getFacing()) === Facing::axis($this->facing));
+	}
+
+	protected function getFacingDegrees() : float{
+		return match($this->facing){
+			Facing::SOUTH => 0,
+			Facing::WEST => 90,
+			Facing::NORTH => 180,
+			Facing::EAST => 270,
+			default => throw new AssumptionFailedError("Invalid facing direction: " . $this->facing),
+		};
 	}
 }

src/block/Chain.php

@@ -33,7 +33,7 @@ use pocketmine\math\Facing;
 final class Chain extends Transparent implements PillarRotation{
 	use PillarRotationTrait;
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return $this->axis === Axis::Y && Facing::axis($facing) === Axis::Y ? SupportType::CENTER : SupportType::NONE;
 	}
 
@@ -41,7 +41,7 @@ final class Chain extends Transparent implements PillarRotation{
 		$bb = AxisAlignedBB::one();
 		foreach([Axis::Y, Axis::Z, Axis::X] as $axis){
 			if($axis !== $this->axis){
-				$bb = $bb->squashedCopy($axis, 13 / 32);
+				$bb->squash($axis, 13 / 32);
 			}
 		}
 		return [$bb];

src/block/ChemistryTable.php

@@ -26,14 +26,13 @@ namespace pocketmine\block;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
 use pocketmine\block\utils\HorizontalFacing;
 use pocketmine\item\Item;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 
 final class ChemistryTable extends Opaque implements HorizontalFacing{
 	use FacesOppositePlacingPlayerTrait;
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		//TODO
 		return false;
 	}

src/block/Chest.php

@@ -39,10 +39,10 @@ class Chest extends Transparent implements HorizontalFacing{
 
 	protected function recalculateCollisionBoxes() : array{
 		//these are slightly bigger than in PC
-		return [AxisAlignedBB::one()->contractedCopy(0.025, 0, 0.025)->trimmedCopy(Facing::UP, 0.05)];
+		return [AxisAlignedBB::one()->contract(0.025, 0, 0.025)->trim(Facing::UP, 0.05)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -51,7 +51,7 @@ class Chest extends Transparent implements HorizontalFacing{
 		$tile = $world->getTile($this->position);
 		if($tile instanceof TileChest){
 			foreach([false, true] as $clockwise){
-				$side = Facing::rotateY($this->facing->toFacing(), $clockwise);
+				$side = Facing::rotateY($this->facing, $clockwise);
 				$c = $this->getSide($side);
 				if($c instanceof Chest && $c->hasSameTypeId($this) && $c->facing === $this->facing){
 					$pair = $world->getTile($c->position);
@@ -70,7 +70,7 @@ class Chest extends Transparent implements HorizontalFacing{
 		}
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 
 			$chest = $this->position->getWorld()->getTile($this->position);

src/block/ChiseledBookshelf.php

@@ -52,7 +52,7 @@ class ChiseledBookshelf extends Opaque implements HorizontalFacing{
 	private ?ChiseledBookshelfSlot $lastInteractedSlot = null;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 		$w->enumSet($this->slots, ChiseledBookshelfSlot::cases());
 	}
 
@@ -143,8 +143,8 @@ class ChiseledBookshelf extends Opaque implements HorizontalFacing{
 		return $this;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
-		if($face !== $this->facing->toFacing()){
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($face !== $this->facing){
 			return false;
 		}
 

src/block/ChorusFlower.php

@@ -106,9 +106,9 @@ final class ChorusFlower extends Flowable implements Ageable{
 		return [$stemHeight, $endStoneBelow];
 	}
 
-	private function allHorizontalBlocksEmpty(World $world, Vector3 $position, ?Facing $except) : bool{
+	private function allHorizontalBlocksEmpty(World $world, Vector3 $position, ?int $except) : bool{
 		foreach($position->sidesAroundAxis(Axis::Y) as $facing => $sidePosition){
-			if($facing === $except?->value){
+			if($facing === $except){
 				continue;
 			}
 			if($world->getBlock($sidePosition)->getTypeId() !== BlockTypeIds::AIR){
@@ -149,7 +149,7 @@ final class ChorusFlower extends Flowable implements Ageable{
 		return $this->allHorizontalBlocksEmpty($world, $up, null);
 	}
 
-	private function grow(Facing $facing, int $ageChange, ?BlockTransaction $tx) : BlockTransaction{
+	private function grow(int $facing, int $ageChange, ?BlockTransaction $tx) : BlockTransaction{
 		if($tx === null){
 			$tx = new BlockTransaction($this->position->getWorld());
 		}
@@ -176,10 +176,10 @@ final class ChorusFlower extends Flowable implements Ageable{
 			$facingVisited = [];
 			for($attempts = 0, $maxAttempts = mt_rand(0, $endStoneBelow ? 4 : 3); $attempts < $maxAttempts; $attempts++){
 				$facing = Facing::HORIZONTAL[array_rand(Facing::HORIZONTAL)];
-				if(isset($facingVisited[$facing->value])){
+				if(isset($facingVisited[$facing])){
 					continue;
 				}
-				$facingVisited[$facing->value] = true;
+				$facingVisited[$facing] = true;
 
 				$sidePosition = $this->position->getSide($facing);
 				if(

src/block/ChorusPlant.php

@@ -43,8 +43,8 @@ final class ChorusPlant extends Flowable{
 	protected function recalculateCollisionBoxes() : array{
 		$bb = AxisAlignedBB::one();
 		foreach(Facing::ALL as $facing){
-			if(!isset($this->connections[$facing->value])){
-				$bb = $bb->trimmedCopy($facing, 2 / 16);
+			if(!isset($this->connections[$facing])){
+				$bb->trim($facing, 2 / 16);
 			}
 		}
 
@@ -62,9 +62,9 @@ final class ChorusPlant extends Flowable{
 				BlockTypeIds::END_STONE, BlockTypeIds::CHORUS_FLOWER, $this->getTypeId() => true,
 				default => false
 			}){
-				$this->connections[$facing->value] = true;
+				$this->connections[$facing] = true;
 			}else{
-				unset($this->connections[$facing->value]);
+				unset($this->connections[$facing]);
 			}
 		}
 

src/block/CocoaBlock.php

@@ -27,13 +27,13 @@ use pocketmine\block\utils\Ageable;
 use pocketmine\block\utils\AgeableTrait;
 use pocketmine\block\utils\BlockEventHelper;
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\WoodType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Fertilizer;
 use pocketmine\item\Item;
 use pocketmine\item\VanillaItems;
+use pocketmine\math\Axis;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
@@ -48,19 +48,18 @@ class CocoaBlock extends Flowable implements Ageable, HorizontalFacing{
 	public const MAX_AGE = 2;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 		$w->boundedIntAuto(0, self::MAX_AGE, $this->age);
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		$realFacing = $this->facing->toFacing();
 		return [
 			AxisAlignedBB::one()
-				->squashedCopy(Facing::axis(Facing::rotateY($realFacing, true)), (6 - $this->age) / 16) //sides
-				->trimmedCopy(Facing::DOWN, (7 - $this->age * 2) / 16)
-				->trimmedCopy(Facing::UP, 0.25)
-				->trimmedCopy(Facing::opposite($realFacing), 1 / 16) //gap between log and pod
-				->trimmedCopy($realFacing, (11 - $this->age * 2) / 16) //outward face
+				->squash(Facing::axis(Facing::rotateY($this->facing, true)), (6 - $this->age) / 16) //sides
+				->trim(Facing::DOWN, (7 - $this->age * 2) / 16)
+				->trim(Facing::UP, 0.25)
+				->trim(Facing::opposite($this->facing), 1 / 16) //gap between log and pod
+				->trim($this->facing, (11 - $this->age * 2) / 16) //outward face
 		];
 	}
 
@@ -68,16 +67,16 @@ class CocoaBlock extends Flowable implements Ageable, HorizontalFacing{
 		return $block instanceof Wood && $block->getWoodType() === WoodType::JUNGLE;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(($hzFacing = HorizontalFacingOption::tryFromFacing($face)) !== null && $this->canAttachTo($blockClicked)){
-			$this->facing = $hzFacing;
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(Facing::axis($face) !== Axis::Y && $this->canAttachTo($blockClicked)){
+			$this->facing = $face;
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
 		return false;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($item instanceof Fertilizer && $this->grow($player)){
 			$item->pop();
 
@@ -88,7 +87,7 @@ class CocoaBlock extends Flowable implements Ageable, HorizontalFacing{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canAttachTo($this->getSide(Facing::opposite($this->facing->toFacing())))){
+		if(!$this->canAttachTo($this->getSide(Facing::opposite($this->facing)))){
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}

src/block/CopperDoor.php

@@ -35,7 +35,7 @@ class CopperDoor extends Door implements CopperMaterial{
 		onInteract as onInteractCopper;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if ($player !== null && $player->isSneaking() && $this->onInteractCopper($item, $face, $clickVector, $player, $returnedItems)) {
 			//copy copper properties to other half
 			$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);

src/block/CopperTrapdoor.php

@@ -26,7 +26,6 @@ namespace pocketmine\block;
 use pocketmine\block\utils\CopperMaterial;
 use pocketmine\block\utils\CopperTrait;
 use pocketmine\item\Item;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 
@@ -35,7 +34,7 @@ class CopperTrapdoor extends Trapdoor implements CopperMaterial{
 		onInteract as onInteractCopper;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if ($player !== null && $player->isSneaking() && $this->onInteractCopper($item, $face, $clickVector, $player, $returnedItems)) {
 			return true;
 		}

src/block/CraftingTable.php

@@ -25,13 +25,12 @@ namespace pocketmine\block;
 
 use pocketmine\block\inventory\CraftingTableInventory;
 use pocketmine\item\Item;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 
 class CraftingTable extends Opaque{
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 			$player->setCurrentWindow(new CraftingTableInventory($this->position));
 		}

src/block/Crops.php

@@ -45,7 +45,7 @@ abstract class Crops extends Flowable implements Ageable{
 		return $block->getSide(Facing::DOWN)->getTypeId() === BlockTypeIds::FARMLAND;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($this->age < self::MAX_AGE && $item instanceof Fertilizer){
 			$block = clone $this;
 			$tempAge = $block->age + mt_rand(2, 5);

src/block/DaylightSensor.php

@@ -64,14 +64,14 @@ class DaylightSensor extends Transparent implements AnalogRedstoneSignalEmitter{
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->trimmedCopy(Facing::UP, 10 / 16)];
+		return [AxisAlignedBB::one()->trim(Facing::UP, 10 / 16)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		$this->inverted = !$this->inverted;
 		$this->signalStrength = $this->recalculateSignalStrength();
 		$this->position->getWorld()->setBlock($this->position, $this);

src/block/Dirt.php

@@ -52,7 +52,7 @@ class Dirt extends Opaque{
 		return $this;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		$world = $this->position->getWorld();
 		if($face !== Facing::DOWN && $item instanceof Hoe){
 			$up = $this->getSide(Facing::UP);

src/block/Door.php

@@ -24,7 +24,6 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
@@ -44,7 +43,7 @@ class Door extends Transparent implements HorizontalFacing{
 	protected bool $open = false;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 		$w->bool($this->top);
 		$w->bool($this->hingeRight);
 		$w->bool($this->open);
@@ -99,10 +98,10 @@ class Door extends Transparent implements HorizontalFacing{
 
 	protected function recalculateCollisionBoxes() : array{
 		//TODO: doors are 0.1825 blocks thick, instead of 0.1875 like JE (https://bugs.mojang.com/browse/MCPE-19214)
-		return [AxisAlignedBB::one()->trimmedCopy($this->open ? Facing::rotateY($this->facing->toFacing(), !$this->hingeRight) : $this->facing->toFacing(), 327 / 400)];
+		return [AxisAlignedBB::one()->trim($this->open ? Facing::rotateY($this->facing, !$this->hingeRight) : $this->facing, 327 / 400)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -112,7 +111,7 @@ class Door extends Transparent implements HorizontalFacing{
 		}
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($face === Facing::UP){
 			$blockUp = $this->getSide(Facing::UP);
 			if(!$blockUp->canBeReplaced() || !$this->canBeSupportedAt($blockReplace)){
@@ -120,13 +119,11 @@ class Door extends Transparent implements HorizontalFacing{
 			}
 
 			if($player !== null){
-				//TODO: not sure if entities should use HorizontalFacingOption too
-				$this->facing = HorizontalFacingOption::fromFacing($player->getHorizontalFacing());
+				$this->facing = $player->getHorizontalFacing();
 			}
 
-			$realFacing = $this->facing->toFacing();
-			$next = $this->getSide(Facing::rotateY($realFacing, false));
-			$next2 = $this->getSide(Facing::rotateY($realFacing, true));
+			$next = $this->getSide(Facing::rotateY($this->facing, false));
+			$next2 = $this->getSide(Facing::rotateY($this->facing, true));
 
 			if($next->hasSameTypeId($this) || (!$next2->isTransparent() && $next->isTransparent())){ //Door hinge
 				$this->hingeRight = true;
@@ -142,7 +139,7 @@ class Door extends Transparent implements HorizontalFacing{
 		return false;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		$this->open = !$this->open;
 
 		$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);

src/block/DoublePitcherCrop.php

@@ -58,10 +58,10 @@ final class DoublePitcherCrop extends DoublePlant implements Ageable{
 		//the pod exists only in the bottom half of the plant
 		return [
 			AxisAlignedBB::one()
-			->trimmedCopy(Facing::UP, 11 / 16)
-			->squashedCopy(Axis::X, 3 / 16)
-			->squashedCopy(Axis::Z, 3 / 16)
-			->extendedCopy(Facing::DOWN, 1 / 16) //presumably this is to correct for farmland being 15/16 of a block tall
+			->trim(Facing::UP, 11 / 16)
+			->squash(Axis::X, 3 / 16)
+			->squash(Axis::Z, 3 / 16)
+			->extend(Facing::DOWN, 1 / 16) //presumably this is to correct for farmland being 15/16 of a block tall
 		];
 	}
 
@@ -89,7 +89,7 @@ final class DoublePitcherCrop extends DoublePlant implements Ageable{
 
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($item instanceof Fertilizer && $this->grow($player)){
 			$item->pop();
 			return true;

src/block/DoublePlant.php

@@ -45,7 +45,7 @@ class DoublePlant extends Flowable{
 		return $this;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		$down = $blockReplace->getSide(Facing::DOWN);
 		if($down->hasTypeTag(BlockTypeTags::DIRT) && $blockReplace->getSide(Facing::UP)->canBeReplaced()){
 			$top = clone $this;

src/block/DragonEgg.php

@@ -28,7 +28,6 @@ use pocketmine\block\utils\FallableTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\event\block\BlockTeleportEvent;
 use pocketmine\item\Item;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\GameMode;
 use pocketmine\player\Player;
@@ -45,12 +44,12 @@ class DragonEgg extends Transparent implements Fallable{
 		return 1;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		$this->teleport();
 		return true;
 	}
 
-	public function onAttack(Item $item, Facing $face, ?Player $player = null) : bool{
+	public function onAttack(Item $item, int $face, ?Player $player = null) : bool{
 		if($player !== null && $player->getGamemode() !== GameMode::CREATIVE){
 			$this->teleport();
 			return true;
@@ -82,7 +81,7 @@ class DragonEgg extends Transparent implements Fallable{
 		}
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 }

src/block/EnchantingTable.php

@@ -34,14 +34,14 @@ use pocketmine\player\Player;
 class EnchantingTable extends Transparent{
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->trimmedCopy(Facing::UP, 0.25)];
+		return [AxisAlignedBB::one()->trim(Facing::UP, 0.25)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 			//TODO lock
 

src/block/EndPortalFrame.php

@@ -35,7 +35,7 @@ class EndPortalFrame extends Opaque implements HorizontalFacing{
 	protected bool $eye = false;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 		$w->bool($this->eye);
 	}
 
@@ -52,6 +52,6 @@ class EndPortalFrame extends Opaque implements HorizontalFacing{
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->trimmedCopy(Facing::UP, 3 / 16)];
+		return [AxisAlignedBB::one()->trim(Facing::UP, 3 / 16)];
 	}
 }

src/block/EndRod.php

@@ -36,7 +36,7 @@ use pocketmine\world\BlockTransaction;
 class EndRod extends Flowable implements AnyFacing{
 	use AnyFacingTrait;
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		$this->facing = $face;
 		if($blockClicked instanceof EndRod && $blockClicked->facing === $this->facing){
 			$this->facing = Facing::opposite($face);
@@ -61,7 +61,7 @@ class EndRod extends Flowable implements AnyFacing{
 			if($axis === $myAxis){
 				continue;
 			}
-			$bb->squashedCopy($axis, 6 / 16);
+			$bb->squash($axis, 6 / 16);
 		}
 		return [$bb];
 	}

src/block/EnderChest.php

@@ -43,14 +43,14 @@ class EnderChest extends Transparent implements HorizontalFacing{
 
 	protected function recalculateCollisionBoxes() : array{
 		//these are slightly bigger than in PC
-		return [AxisAlignedBB::one()->contractedCopy(0.025, 0, 0.025)->trimmedCopy(Facing::UP, 0.05)];
+		return [AxisAlignedBB::one()->contract(0.025, 0, 0.025)->trim(Facing::UP, 0.05)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 			$enderChest = $this->position->getWorld()->getTile($this->position);
 			if($enderChest instanceof TileEnderChest && $this->getSide(Facing::UP)->isTransparent()){

src/block/Farmland.php

@@ -95,7 +95,7 @@ class Farmland extends Transparent{
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->trimmedCopy(Facing::UP, 1 / 16)];
+		return [AxisAlignedBB::one()->trim(Facing::UP, 1 / 16)];
 	}
 
 	public function onNearbyBlockChange() : void{

src/block/Fence.php

@@ -45,9 +45,9 @@ class Fence extends Transparent{
 		foreach(Facing::HORIZONTAL as $facing){
 			$block = $this->getSide($facing);
 			if($block instanceof static || $block instanceof FenceGate || $block->getSupportType(Facing::opposite($facing)) === SupportType::FULL){
-				$this->connections[$facing->value] = true;
+				$this->connections[$facing] = true;
 			}else{
-				unset($this->connections[$facing->value]);
+				unset($this->connections[$facing]);
 			}
 		}
 
@@ -59,43 +59,43 @@ class Fence extends Transparent{
 
 		$bbs = [];
 
-		$connectWest = isset($this->connections[Facing::WEST->value]);
-		$connectEast = isset($this->connections[Facing::EAST->value]);
+		$connectWest = isset($this->connections[Facing::WEST]);
+		$connectEast = isset($this->connections[Facing::EAST]);
 
 		if($connectWest || $connectEast){
 			//X axis (west/east)
 			$bbs[] = AxisAlignedBB::one()
-				->squashedCopy(Axis::Z, $inset)
-				->extendedCopy(Facing::UP, 0.5)
-				->trimmedCopy(Facing::WEST, $connectWest ? 0 : $inset)
-				->trimmedCopy(Facing::EAST, $connectEast ? 0 : $inset);
+				->squash(Axis::Z, $inset)
+				->extend(Facing::UP, 0.5)
+				->trim(Facing::WEST, $connectWest ? 0 : $inset)
+				->trim(Facing::EAST, $connectEast ? 0 : $inset);
 		}
 
-		$connectNorth = isset($this->connections[Facing::NORTH->value]);
-		$connectSouth = isset($this->connections[Facing::SOUTH->value]);
+		$connectNorth = isset($this->connections[Facing::NORTH]);
+		$connectSouth = isset($this->connections[Facing::SOUTH]);
 
 		if($connectNorth || $connectSouth){
 			//Z axis (north/south)
 			$bbs[] = AxisAlignedBB::one()
-				->squashedCopy(Axis::X, $inset)
-				->extendedCopy(Facing::UP, 0.5)
-				->trimmedCopy(Facing::NORTH, $connectNorth ? 0 : $inset)
-				->trimmedCopy(Facing::SOUTH, $connectSouth ? 0 : $inset);
+				->squash(Axis::X, $inset)
+				->extend(Facing::UP, 0.5)
+				->trim(Facing::NORTH, $connectNorth ? 0 : $inset)
+				->trim(Facing::SOUTH, $connectSouth ? 0 : $inset);
 		}
 
 		if(count($bbs) === 0){
 			//centre post AABB (only needed if not connected on any axis - other BBs overlapping will do this if any connections are made)
 			return [
 				AxisAlignedBB::one()
-					->extendedCopy(Facing::UP, 0.5)
-					->contractedCopy($inset, 0, $inset)
+					->extend(Facing::UP, 0.5)
+					->contract($inset, 0, $inset)
 			];
 		}
 
 		return $bbs;
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return Facing::axis($facing) === Axis::Y ? SupportType::CENTER : SupportType::NONE;
 	}
 }

src/block/FenceGate.php

@@ -24,7 +24,6 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\block\utils\WoodMaterial;
@@ -46,7 +45,7 @@ class FenceGate extends Transparent implements HorizontalFacing, WoodMaterial{
 	protected bool $inWall = false;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 		$w->bool($this->open);
 		$w->bool($this->inWall);
 	}
@@ -68,24 +67,23 @@ class FenceGate extends Transparent implements HorizontalFacing, WoodMaterial{
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		return $this->open ? [] : [AxisAlignedBB::one()->extendedCopy(Facing::UP, 0.5)->squashedCopy(Facing::axis($this->facing->toFacing()), 6 / 16)];
+		return $this->open ? [] : [AxisAlignedBB::one()->extend(Facing::UP, 0.5)->squash(Facing::axis($this->facing), 6 / 16)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
 	private function checkInWall() : bool{
-		$realFacing = $this->facing->toFacing();
 		return (
-			$this->getSide(Facing::rotateY($realFacing, false)) instanceof Wall ||
-			$this->getSide(Facing::rotateY($realFacing, true)) instanceof Wall
+			$this->getSide(Facing::rotateY($this->facing, false)) instanceof Wall ||
+			$this->getSide(Facing::rotateY($this->facing, true)) instanceof Wall
 		);
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player !== null){
-			$this->facing = HorizontalFacingOption::fromFacing($player->getHorizontalFacing());
+			$this->facing = $player->getHorizontalFacing();
 		}
 
 		$this->inWall = $this->checkInWall();
@@ -101,12 +99,12 @@ class FenceGate extends Transparent implements HorizontalFacing, WoodMaterial{
 		}
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		$this->open = !$this->open;
 		if($this->open && $player !== null){
 			$playerFacing = $player->getHorizontalFacing();
-			if($playerFacing === Facing::opposite($this->facing->toFacing())){
-				$this->facing = HorizontalFacingOption::fromFacing($playerFacing);
+			if($playerFacing === Facing::opposite($this->facing)){
+				$this->facing = $playerFacing;
 			}
 		}
 

src/block/FillableCauldron.php

@@ -54,16 +54,16 @@ abstract class FillableCauldron extends Transparent{
 
 	protected function recalculateCollisionBoxes() : array{
 		$result = [
-			AxisAlignedBB::one()->trimmedCopy(Facing::UP, 11 / 16) //bottom of the cauldron
+			AxisAlignedBB::one()->trim(Facing::UP, 11 / 16) //bottom of the cauldron
 		];
 
 		foreach(Facing::HORIZONTAL as $f){ //add the frame parts around the bowl
-			$result[] = AxisAlignedBB::one()->trimmedCopy($f, 14 / 16);
+			$result[] = AxisAlignedBB::one()->trim($f, 14 / 16);
 		}
 		return $result;
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return $facing === Facing::UP ? SupportType::EDGE : SupportType::NONE;
 	}
 

src/block/FloorBanner.php

@@ -38,11 +38,11 @@ final class FloorBanner extends BaseBanner implements SignLikeRotation{
 		return VanillaBlocks::OMINOUS_BANNER()->setRotation($this->rotation);
 	}
 
-	protected function getSupportingFace() : Facing{
+	protected function getSupportingFace() : int{
 		return Facing::DOWN;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($face !== Facing::UP){
 			return false;
 		}

src/block/FloorCoralFan.php

@@ -38,16 +38,16 @@ use function rad2deg;
 final class FloorCoralFan extends BaseCoral{
 	use StaticSupportTrait;
 
-	private Axis $axis = Axis::X;
+	private int $axis = Axis::X;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
 		$w->horizontalAxis($this->axis);
 	}
 
-	public function getAxis() : Axis{ return $this->axis; }
+	public function getAxis() : int{ return $this->axis; }
 
 	/** @return $this */
-	public function setAxis(Axis $axis) : self{
+	public function setAxis(int $axis) : self{
 		if($axis !== Axis::X && $axis !== Axis::Z){
 			throw new \InvalidArgumentException("Axis must be X or Z only");
 		}
@@ -55,7 +55,7 @@ final class FloorCoralFan extends BaseCoral{
 		return $this;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player !== null){
 			$playerBlockPos = $player->getPosition()->floor();
 			$directionVector = $blockReplace->position->subtractVector($playerBlockPos)->normalize();

src/block/FloorSign.php

@@ -34,11 +34,11 @@ use pocketmine\world\BlockTransaction;
 final class FloorSign extends BaseSign implements SignLikeRotation{
 	use SignLikeRotationTrait;
 
-	protected function getSupportingFace() : Facing{
+	protected function getSupportingFace() : int{
 		return Facing::DOWN;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($face !== Facing::UP){
 			return false;
 		}
@@ -48,4 +48,8 @@ final class FloorSign extends BaseSign implements SignLikeRotation{
 		}
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
+
+	protected function getFacingDegrees() : float{
+		return $this->rotation * 22.5;
+	}
 }

src/block/Flowable.php

@@ -24,7 +24,6 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\SupportType;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 
 /**
@@ -41,7 +40,7 @@ abstract class Flowable extends Transparent{
 		return false;
 	}
 
-	public function canBePlacedAt(Block $blockReplace, Vector3 $clickVector, Facing $face, bool $isClickedBlock) : bool{
+	public function canBePlacedAt(Block $blockReplace, Vector3 $clickVector, int $face, bool $isClickedBlock) : bool{
 		return (!$this->canBeFlowedInto() || !$blockReplace instanceof Liquid) &&
 			parent::canBePlacedAt($blockReplace, $clickVector, $face, $isClickedBlock);
 	}
@@ -50,7 +49,7 @@ abstract class Flowable extends Transparent{
 		return [];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 }

src/block/FlowerPot.php

@@ -84,14 +84,14 @@ class FlowerPot extends Flowable{
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->contractedCopy(3 / 16, 0, 3 / 16)->trimmedCopy(Facing::UP, 5 / 8)];
+		return [AxisAlignedBB::one()->contract(3 / 16, 0, 3 / 16)->trim(Facing::UP, 5 / 8)];
 	}
 
 	private function canBeSupportedAt(Block $block) : bool{
 		return $block->getAdjacentSupportType(Facing::DOWN)->hasCenterSupport();
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		$world = $this->position->getWorld();
 		$plant = $item->getBlock();
 		if($this->plant !== null){

src/block/Furnace.php

@@ -31,7 +31,6 @@ use pocketmine\block\utils\LightableTrait;
 use pocketmine\crafting\FurnaceType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Item;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use function mt_rand;
@@ -48,7 +47,7 @@ class Furnace extends Opaque implements Lightable, HorizontalFacing{
 	}
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 		$w->bool($this->lit);
 	}
 
@@ -60,7 +59,7 @@ class Furnace extends Opaque implements Lightable, HorizontalFacing{
 		return $this->lit ? 13 : 0;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	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);
 			if($furnace instanceof TileFurnace && $furnace->canOpenWith($item->getCustomName())){

src/block/GlowLichen.php

@@ -51,7 +51,7 @@ class GlowLichen extends Transparent implements MultiAnyFacing{
 		return [];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -60,13 +60,13 @@ class GlowLichen extends Transparent implements MultiAnyFacing{
 	}
 
 	/**
-	 * @return Facing[]
+	 * @return int[]
 	 */
 	protected function getInitialPlaceFaces(Block $blockReplace) : array{
 		return $blockReplace instanceof GlowLichen ? $blockReplace->faces : [];
 	}
 
-	private function getSpreadBlock(Block $replace, Facing $spreadFace) : ?Block{
+	private function getSpreadBlock(Block $replace, int $spreadFace) : ?Block{
 		if($replace instanceof self && $replace->hasSameTypeId($this)){
 			if($replace->hasFace($spreadFace)){
 				return null;
@@ -81,7 +81,7 @@ class GlowLichen extends Transparent implements MultiAnyFacing{
 		return $result->setFace($spreadFace, true);
 	}
 
-	private function spread(World $world, Vector3 $replacePos, Facing $spreadFace) : bool{
+	private function spread(World $world, Vector3 $replacePos, int $spreadFace) : bool{
 		$supportBlock = $world->getBlock($replacePos->getSide($spreadFace));
 		$supportFace = Facing::opposite($spreadFace);
 
@@ -99,9 +99,9 @@ class GlowLichen extends Transparent implements MultiAnyFacing{
 	}
 
 	/**
-	 * @phpstan-return \Generator<int, Facing, void, void>
+	 * @phpstan-return \Generator<int, int, void, void>
 	 */
-	private static function getShuffledSpreadFaces(Facing $sourceFace) : \Generator{
+	private static function getShuffledSpreadFaces(int $sourceFace) : \Generator{
 		$skipAxis = Facing::axis($sourceFace);
 
 		$faces = Facing::ALL;
@@ -113,7 +113,7 @@ class GlowLichen extends Transparent implements MultiAnyFacing{
 		}
 	}
 
-	private function spreadAroundSupport(Facing $sourceFace) : bool{
+	private function spreadAroundSupport(int $sourceFace) : bool{
 		$world = $this->position->getWorld();
 
 		$supportPos = $this->position->getSide($sourceFace);
@@ -127,7 +127,7 @@ class GlowLichen extends Transparent implements MultiAnyFacing{
 		return false;
 	}
 
-	private function spreadAdjacentToSupport(Facing $sourceFace) : bool{
+	private function spreadAdjacentToSupport(int $sourceFace) : bool{
 		$world = $this->position->getWorld();
 
 		foreach(self::getShuffledSpreadFaces($sourceFace) as $spreadFace){
@@ -139,7 +139,7 @@ class GlowLichen extends Transparent implements MultiAnyFacing{
 		return false;
 	}
 
-	private function spreadWithinSelf(Facing $sourceFace) : bool{
+	private function spreadWithinSelf(int $sourceFace) : bool{
 		foreach(self::getShuffledSpreadFaces($sourceFace) as $spreadFace){
 			if(!$this->hasFace($spreadFace) && $this->spread($this->position->getWorld(), $this->position, $spreadFace)){
 				return true;
@@ -149,7 +149,7 @@ class GlowLichen extends Transparent implements MultiAnyFacing{
 		return false;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($item instanceof Fertilizer && count($this->faces) > 0){
 			$shuffledFaces = $this->faces;
 			shuffle($shuffledFaces);

src/block/Grass.php

@@ -81,7 +81,7 @@ class Grass extends Opaque{
 		}
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($this->getSide(Facing::UP)->getTypeId() !== BlockTypeIds::AIR){
 			return false;
 		}

src/block/GrassPath.php

@@ -30,7 +30,7 @@ use pocketmine\math\Facing;
 class GrassPath extends Transparent{
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->trimmedCopy(Facing::UP, 1 / 16)];
+		return [AxisAlignedBB::one()->trim(Facing::UP, 1 / 16)];
 	}
 
 	public function onNearbyBlockChange() : void{

src/block/Hopper.php

@@ -38,17 +38,17 @@ use pocketmine\world\BlockTransaction;
 class Hopper extends Transparent implements PoweredByRedstone{
 	use PoweredByRedstoneTrait;
 
-	private Facing $facing = Facing::DOWN;
+	private int $facing = Facing::DOWN;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
 		$w->facingExcept($this->facing, Facing::UP);
 		$w->bool($this->powered);
 	}
 
-	public function getFacing() : Facing{ return $this->facing; }
+	public function getFacing() : int{ return $this->facing; }
 
 	/** @return $this */
-	public function setFacing(Facing $facing) : self{
+	public function setFacing(int $facing) : self{
 		if($facing === Facing::UP){
 			throw new \InvalidArgumentException("Hopper may not face upward");
 		}
@@ -58,16 +58,16 @@ class Hopper extends Transparent implements PoweredByRedstone{
 
 	protected function recalculateCollisionBoxes() : array{
 		$result = [
-			AxisAlignedBB::one()->trimmedCopy(Facing::UP, 6 / 16) //the empty area around the bottom is currently considered solid
+			AxisAlignedBB::one()->trim(Facing::UP, 6 / 16) //the empty area around the bottom is currently considered solid
 		];
 
 		foreach(Facing::HORIZONTAL as $f){ //add the frame parts around the bowl
-			$result[] = AxisAlignedBB::one()->trimmedCopy($f, 14 / 16);
+			$result[] = AxisAlignedBB::one()->trim($f, 14 / 16);
 		}
 		return $result;
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return match($facing){
 			Facing::UP => SupportType::FULL,
 			Facing::DOWN => $this->facing === Facing::DOWN ? SupportType::CENTER : SupportType::NONE,
@@ -75,13 +75,13 @@ class Hopper extends Transparent implements PoweredByRedstone{
 		};
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		$this->facing = $face === Facing::DOWN ? Facing::DOWN : Facing::opposite($face);
 
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player !== null){
 			$tile = $this->position->getWorld()->getTile($this->position);
 			if($tile instanceof TileHopper){ //TODO: find a way to have inventories open on click without this boilerplate in every block

src/block/ItemFrame.php

@@ -52,7 +52,7 @@ class ItemFrame extends Flowable implements AnyFacing{
 	protected float $itemDropChance = 1.0;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->facing($this->facing);
 		$w->bool($this->hasMap);
 	}
 
@@ -132,7 +132,7 @@ class ItemFrame extends Flowable implements AnyFacing{
 		return $this;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($this->framedItem !== null){
 			$this->itemRotation = ($this->itemRotation + 1) % self::ROTATIONS;
 
@@ -150,7 +150,7 @@ class ItemFrame extends Flowable implements AnyFacing{
 		return true;
 	}
 
-	public function onAttack(Item $item, Facing $face, ?Player $player = null) : bool{
+	public function onAttack(Item $item, int $face, ?Player $player = null) : bool{
 		if($this->framedItem === null){
 			return false;
 		}
@@ -164,7 +164,7 @@ class ItemFrame extends Flowable implements AnyFacing{
 		return true;
 	}
 
-	private function canBeSupportedAt(Block $block, Facing $face) : bool{
+	private function canBeSupportedAt(Block $block, int $face) : bool{
 		return $block->getAdjacentSupportType($face) !== SupportType::NONE;
 	}
 
@@ -174,7 +174,7 @@ class ItemFrame extends Flowable implements AnyFacing{
 		}
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if(!$this->canBeSupportedAt($blockReplace, Facing::opposite($face))){
 			return false;
 		}

src/block/Jukebox.php

@@ -27,7 +27,6 @@ use pocketmine\block\tile\Jukebox as JukeboxTile;
 use pocketmine\item\Item;
 use pocketmine\item\Record;
 use pocketmine\lang\KnownTranslationFactory;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\world\sound\RecordSound;
@@ -41,7 +40,7 @@ class Jukebox extends Opaque{
 		return 300;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player instanceof Player){
 			if($this->record !== null){
 				$this->ejectRecord();

src/block/Ladder.php

@@ -24,12 +24,12 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\entity\Entity;
 use pocketmine\entity\Living;
 use pocketmine\item\Item;
+use pocketmine\math\Axis;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
@@ -60,16 +60,16 @@ class Ladder extends Transparent implements HorizontalFacing{
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->trimmedCopy($this->facing->toFacing(), 13 / 16)];
+		return [AxisAlignedBB::one()->trim($this->facing, 13 / 16)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		if(($hzFacing = HorizontalFacingOption::tryFromFacing($face)) !== null && $this->canBeSupportedAt($blockReplace, Facing::opposite($face))){
-			$this->facing = $hzFacing;
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($this->canBeSupportedAt($blockReplace, Facing::opposite($face)) && Facing::axis($face) !== Axis::Y){
+			$this->facing = $face;
 			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
@@ -77,12 +77,12 @@ class Ladder extends Transparent implements HorizontalFacing{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->canBeSupportedAt($this, Facing::opposite($this->facing->toFacing()))){ //Replace with common break method
+		if(!$this->canBeSupportedAt($this, Facing::opposite($this->facing))){ //Replace with common break method
 			$this->position->getWorld()->useBreakOn($this->position);
 		}
 	}
 
-	private function canBeSupportedAt(Block $block, Facing $face) : bool{
+	private function canBeSupportedAt(Block $block, int $face) : bool{
 		return $block->getAdjacentSupportType($face) === SupportType::FULL;
 	}
 }

src/block/Lantern.php

@@ -62,18 +62,18 @@ class Lantern extends Transparent{
 	protected function recalculateCollisionBoxes() : array{
 		return [
 			AxisAlignedBB::one()
-				->trimmedCopy(Facing::UP,   $this->hanging ? 6 / 16 : 8 / 16)
-				->trimmedCopy(Facing::DOWN, $this->hanging ? 2 / 16 : 0)
-				->squashedCopy(Axis::X, 5 / 16)
-				->squashedCopy(Axis::Z, 5 / 16)
+				->trim(Facing::UP,   $this->hanging ? 6 / 16 : 8 / 16)
+				->trim(Facing::DOWN, $this->hanging ? 2 / 16 : 0)
+				->squash(Axis::X, 5 / 16)
+				->squash(Axis::Z, 5 / 16)
 		];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		$downSupport = $this->canBeSupportedAt($blockReplace, Facing::DOWN);
 		if(!$downSupport && !$this->canBeSupportedAt($blockReplace, Facing::UP)){
 			return false;
@@ -90,7 +90,7 @@ class Lantern extends Transparent{
 		}
 	}
 
-	private function canBeSupportedAt(Block $block, Facing $face) : bool{
+	private function canBeSupportedAt(Block $block, int $face) : bool{
 		return $block->getAdjacentSupportType($face)->hasCenterSupport();
 	}
 }

src/block/LavaCauldron.php

@@ -31,7 +31,6 @@ use pocketmine\event\entity\EntityDamageEvent;
 use pocketmine\item\Item;
 use pocketmine\item\ItemTypeIds;
 use pocketmine\item\VanillaItems;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\world\sound\CauldronEmptyLavaSound;
@@ -62,7 +61,7 @@ final class LavaCauldron extends FillableCauldron{
 		return new CauldronEmptyLavaSound();
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		match($item->getTypeId()){
 			ItemTypeIds::BUCKET => $this->removeFillLevels(self::MAX_FILL_LEVEL, $item, VanillaItems::LAVA_BUCKET(), $returnedItems),
 			ItemTypeIds::POWDER_SNOW_BUCKET, ItemTypeIds::WATER_BUCKET => $this->mix($item, VanillaItems::BUCKET(), $returnedItems),

src/block/Leaves.php

@@ -134,7 +134,7 @@ class Leaves extends Transparent{
 		}
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		$this->noDecay = true; //artificial leaves don't decay
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
@@ -188,7 +188,7 @@ class Leaves extends Transparent{
 		return 60;
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 }

src/block/Lectern.php

@@ -46,7 +46,7 @@ class Lectern extends Transparent implements HorizontalFacing{
 	protected bool $producingSignal = false;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 		$w->bool($this->producingSignal);
 	}
 
@@ -84,10 +84,10 @@ class Lectern extends Transparent implements HorizontalFacing{
 	}
 
 	protected function recalculateCollisionBoxes() : array{
-		return [AxisAlignedBB::one()->trimmedCopy(Facing::UP, 0.1)];
+		return [AxisAlignedBB::one()->trim(Facing::UP, 0.1)];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -120,7 +120,7 @@ class Lectern extends Transparent implements HorizontalFacing{
 		return $this;
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($this->book === null && $item instanceof WritableBookBase){
 			$world = $this->position->getWorld();
 			$world->setBlock($this->position, $this->setBook($item));
@@ -130,7 +130,7 @@ class Lectern extends Transparent implements HorizontalFacing{
 		return true;
 	}
 
-	public function onAttack(Item $item, Facing $face, ?Player $player = null) : bool{
+	public function onAttack(Item $item, int $face, ?Player $player = null) : bool{
 		if($this->book !== null){
 			$world = $this->position->getWorld();
 			$world->dropItem($this->position->up(), $this->book);

src/block/Lever.php

@@ -30,6 +30,7 @@ use pocketmine\math\Axis;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
+use pocketmine\utils\AssumptionFailedError;
 use pocketmine\world\BlockTransaction;
 use pocketmine\world\sound\RedstonePowerOffSound;
 use pocketmine\world\sound\RedstonePowerOnSound;
@@ -59,7 +60,7 @@ class Lever extends Flowable{
 		return $this;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if(!$this->canBeSupportedAt($blockReplace, Facing::opposite($face))){
 			return false;
 		}
@@ -77,6 +78,7 @@ class Lever extends Flowable{
 			Facing::SOUTH => LeverFacing::SOUTH,
 			Facing::WEST => LeverFacing::WEST,
 			Facing::EAST => LeverFacing::EAST,
+			default => throw new AssumptionFailedError("Bad facing value"),
 		};
 
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
@@ -88,7 +90,7 @@ class Lever extends Flowable{
 		}
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		$this->activated = !$this->activated;
 		$world = $this->position->getWorld();
 		$world->setBlock($this->position, $this);
@@ -99,7 +101,7 @@ class Lever extends Flowable{
 		return true;
 	}
 
-	private function canBeSupportedAt(Block $block, Facing $face) : bool{
+	private function canBeSupportedAt(Block $block, int $face) : bool{
 		return $block->getAdjacentSupportType($face)->hasCenterSupport();
 	}
 

src/block/Light.php

@@ -25,7 +25,6 @@ namespace pocketmine\block;
 
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Item;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 
@@ -52,12 +51,12 @@ final class Light extends Flowable{
 
 	public function canBeReplaced() : bool{ return true; }
 
-	public function canBePlacedAt(Block $blockReplace, Vector3 $clickVector, Facing $face, bool $isClickedBlock) : bool{
+	public function canBePlacedAt(Block $blockReplace, Vector3 $clickVector, int $face, bool $isClickedBlock) : bool{
 		//light blocks behave like solid blocks when placing them on another light block
 		return $blockReplace->canBeReplaced() && $blockReplace->getTypeId() !== $this->getTypeId();
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		$this->level = $this->level === self::MAX_LIGHT_LEVEL ?
 			self::MIN_LIGHT_LEVEL :
 			$this->level + 1;

src/block/LightningRod.php

@@ -42,14 +42,14 @@ final class LightningRod extends Transparent implements AnyFacing{
 		$result = AxisAlignedBB::one();
 		foreach([Axis::X, Axis::Y, Axis::Z] as $axis){
 			if($axis !== $myAxis){
-				$result = $result->squashedCopy($axis, 6 / 16);
+				$result->squash($axis, 6 / 16);
 			}
 		}
 
 		return [$result];
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		$this->facing = $face;
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}

src/block/Liquid.php

@@ -92,7 +92,7 @@ abstract class Liquid extends Transparent{
 		return [];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -170,7 +170,7 @@ abstract class Liquid extends Transparent{
 		$world = $this->position->getWorld();
 
 		foreach(Facing::HORIZONTAL as $j){
-			[$dx, $dy, $dz] = Facing::OFFSET[$j->value];
+			[$dx, $dy, $dz] = Facing::OFFSET[$j];
 
 			$sideX = $x + $dx;
 			$sideY = $y + $dy;
@@ -206,7 +206,7 @@ abstract class Liquid extends Transparent{
 
 		if($this->falling){
 			foreach(Facing::HORIZONTAL as $facing){
-				[$dx, $dy, $dz] = Facing::OFFSET[$facing->value];
+				[$dx, $dy, $dz] = Facing::OFFSET[$facing];
 				if(
 					!$this->canFlowInto($world->getBlockAt($x + $dx, $y + $dy, $z + $dz)) ||
 					!$this->canFlowInto($world->getBlockAt($x + $dx, $y + $dy + 1, $z + $dz))

src/block/Loom.php

@@ -27,14 +27,13 @@ use pocketmine\block\inventory\LoomInventory;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
 use pocketmine\block\utils\HorizontalFacing;
 use pocketmine\item\Item;
-use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 
 final class Loom extends Opaque implements HorizontalFacing{
 	use FacesOppositePlacingPlayerTrait;
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($player !== null){
 			$player->setCurrentWindow(new LoomInventory($this->position));
 			return true;

src/block/MobHead.php

@@ -41,7 +41,7 @@ class MobHead extends Flowable{
 
 	protected MobHeadType $mobHeadType = MobHeadType::SKELETON;
 
-	protected Facing $facing = Facing::NORTH;
+	protected int $facing = Facing::NORTH;
 	protected int $rotation = self::MIN_ROTATION; //TODO: split this into floor skull and wall skull handling
 
 	public function describeBlockItemState(RuntimeDataDescriber $w) : void{
@@ -82,10 +82,10 @@ class MobHead extends Flowable{
 		return $this;
 	}
 
-	public function getFacing() : Facing{ return $this->facing; }
+	public function getFacing() : int{ return $this->facing; }
 
 	/** @return $this */
-	public function setFacing(Facing $facing) : self{
+	public function setFacing(int $facing) : self{
 		if($facing === Facing::DOWN){
 			throw new \InvalidArgumentException("Skull may not face DOWN");
 		}
@@ -106,17 +106,17 @@ class MobHead extends Flowable{
 
 	protected function recalculateCollisionBoxes() : array{
 		$collisionBox = AxisAlignedBB::one()
-			->contractedCopy(0.25, 0, 0.25)
-			->trimmedCopy(Facing::UP, 0.5);
+			->contract(0.25, 0, 0.25)
+			->trim(Facing::UP, 0.5);
 		if($this->facing !== Facing::UP){
 			$collisionBox = $collisionBox
-				->offsetTowardsCopy(Facing::opposite($this->facing), 0.25)
-				->offsetTowardsCopy(Facing::UP, 0.25);
+				->offsetTowards(Facing::opposite($this->facing), 0.25)
+				->offsetTowards(Facing::UP, 0.25);
 		}
 		return [$collisionBox];
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($face === Facing::DOWN){
 			return false;
 		}

src/block/MonsterSpawner.php

@@ -25,7 +25,6 @@ namespace pocketmine\block;
 
 use pocketmine\block\utils\SupportType;
 use pocketmine\item\Item;
-use pocketmine\math\Facing;
 use function mt_rand;
 
 class MonsterSpawner extends Transparent{
@@ -42,7 +41,7 @@ class MonsterSpawner extends Transparent{
 		//TODO
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 }

src/block/NetherPortal.php

@@ -28,17 +28,16 @@ use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\entity\Entity;
 use pocketmine\item\Item;
 use pocketmine\math\Axis;
-use pocketmine\math\Facing;
 
 class NetherPortal extends Transparent{
 
-	protected Axis $axis = Axis::X;
+	protected int $axis = Axis::X;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
 		$w->horizontalAxis($this->axis);
 	}
 
-	public function getAxis() : Axis{
+	public function getAxis() : int{
 		return $this->axis;
 	}
 
@@ -46,7 +45,7 @@ class NetherPortal extends Transparent{
 	 * @throws \InvalidArgumentException
 	 * @return $this
 	 */
-	public function setAxis(Axis $axis) : self{
+	public function setAxis(int $axis) : self{
 		if($axis !== Axis::X && $axis !== Axis::Z){
 			throw new \InvalidArgumentException("Invalid axis");
 		}
@@ -66,7 +65,7 @@ class NetherPortal extends Transparent{
 		return [];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 

src/block/NetherVines.php

@@ -49,9 +49,9 @@ class NetherVines extends Flowable implements Ageable{
 	public const MAX_AGE = 25;
 
 	/** Direction the vine grows towards. */
-	private Facing $growthFace;
+	private int $growthFace;
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo, Facing $growthFace){
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo, int $growthFace){
 		$this->growthFace = $growthFace;
 		parent::__construct($idInfo, $name, $typeInfo);
 	}
@@ -80,12 +80,12 @@ class NetherVines extends Flowable implements Ageable{
 		return $top;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		$this->age = mt_rand(0, self::MAX_AGE - 1);
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
 		if($item instanceof Fertilizer){
 			if($this->grow($player, mt_rand(1, 5))){
 				$item->pop();
@@ -159,7 +159,7 @@ class NetherVines extends Flowable implements Ageable{
 		return [];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 }

src/block/OminousFloorBanner.php

@@ -36,11 +36,11 @@ final class OminousFloorBanner extends BaseOminousBanner implements SignLikeRota
 
 	//TODO: duplicated code :(
 
-	protected function getSupportingFace() : Facing{
+	protected function getSupportingFace() : int{
 		return Facing::DOWN;
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($face !== Facing::UP){
 			return false;
 		}

src/block/OminousWallBanner.php

@@ -24,9 +24,9 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\item\Item;
+use pocketmine\math\Axis;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
@@ -35,16 +35,15 @@ use pocketmine\world\BlockTransaction;
 final class OminousWallBanner extends BaseOminousBanner implements HorizontalFacing{
 	use HorizontalFacingTrait;
 
-	protected function getSupportingFace() : Facing{
-		return Facing::opposite($this->facing->toFacing());
+	protected function getSupportingFace() : int{
+		return Facing::opposite($this->facing);
 	}
 
-	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
-		$hzFacing = HorizontalFacingOption::tryFromFacing($face);
-		if($hzFacing === null){
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(Facing::axis($face) === Axis::Y){
 			return false;
 		}
-		$this->facing = $hzFacing;
+		$this->facing = $face;
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 }