EndCrystal: defer explosion until next tick update

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

@@ -20,7 +20,7 @@ jobs:
       - name: Setup PHP and tools
         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

@@ -51,7 +51,7 @@ jobs:
       - name: Setup PHP
         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:

.github/workflows/main.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        php: ["8.3", "8.4"]
+        php: ["8.1", "8.2", "8.3", "8.4"]
 
     uses: ./.github/workflows/main-php-matrix.yml
     with:

.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')

composer.json

@@ -5,7 +5,7 @@
    "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",
@@ -36,26 +36,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": "~41.0.0+bedrock-1.21.100",
+      "pocketmine/bedrock-protocol": "~40.0.0+bedrock-1.21.100",
       "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/math": "~1.0.0",
       "pocketmine/nbt": "~1.1.0",
       "pocketmine/raklib": "~1.2.0",
       "pocketmine/raklib-ipc": "~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 +77,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

@@ -2,6 +2,7 @@ includes:
 	- tests/phpstan/analyse-for-current-php-version.neon.php
 	- tests/phpstan/configs/actual-problems.neon
 	- 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
@@ -11,7 +12,9 @@ includes:
 	- 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

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/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

@@ -23,14 +23,11 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\inventory\window\AnvilInventoryWindow;
+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\MenuAccessor;
-use pocketmine\block\utils\MenuAccessorTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\entity\object\FallingBlock;
@@ -41,15 +38,13 @@ use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\utils\Utils;
 use pocketmine\world\BlockTransaction;
-use pocketmine\world\Position;
 use pocketmine\world\sound\AnvilFallSound;
 use pocketmine\world\sound\Sound;
 use function round;
 
-class Anvil extends Transparent implements Fallable, HorizontalFacing, MenuAccessor{
+class Anvil extends Transparent implements Fallable, HorizontalFacing{
 	use FallableTrait;
 	use HorizontalFacingTrait;
-	use MenuAccessorTrait;
 
 	public const UNDAMAGED = 0;
 	public const SLIGHTLY_DAMAGED = 1;
@@ -62,7 +57,7 @@ class Anvil extends Transparent implements Fallable, HorizontalFacing, MenuAcces
 	}
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 	}
 
 	public function getDamage() : int{ return $this->damage; }
@@ -77,20 +72,24 @@ class Anvil extends Transparent implements Fallable, HorizontalFacing, MenuAcces
 	}
 
 	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;
 	}
 
-	protected function newMenu(Player $player, Position $position) : AnvilInventoryWindow{
-		return new AnvilInventoryWindow($player, $position);
+	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));
+		}
+
+		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

@@ -23,33 +23,24 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\AnimatedContainerLike;
-use pocketmine\block\utils\AnimatedContainerLikeTrait;
+use pocketmine\block\tile\Barrel as TileBarrel;
 use pocketmine\block\utils\AnyFacing;
 use pocketmine\block\utils\AnyFacingTrait;
-use pocketmine\block\utils\Container;
-use pocketmine\block\utils\ContainerTrait;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\item\Item;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
-use pocketmine\world\Position;
-use pocketmine\world\sound\BarrelCloseSound;
-use pocketmine\world\sound\BarrelOpenSound;
-use pocketmine\world\sound\Sound;
 use function abs;
 
-class Barrel extends Opaque implements AnimatedContainerLike, AnyFacing, Container{
-	use AnimatedContainerLikeTrait;
+class Barrel extends Opaque implements AnyFacing{
 	use AnyFacingTrait;
-	use ContainerTrait;
 
 	protected bool $open = false;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->facing($this->facing);
 		$w->bool($this->open);
 	}
 
@@ -63,7 +54,7 @@ class Barrel extends Opaque implements AnimatedContainerLike, AnyFacing, Contain
 		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;
@@ -83,23 +74,22 @@ class Barrel extends Opaque implements AnimatedContainerLike, AnyFacing, Contain
 		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($player instanceof Player){
+			$barrel = $this->position->getWorld()->getTile($this->position);
+			if($barrel instanceof TileBarrel){
+				if(!$barrel->canOpenWith($item->getCustomName())){
+					return true;
+				}
+
+				$player->setCurrentWindow($barrel->getInventory());
+			}
+		}
+
+		return true;
+	}
+
 	public function getFuelTime() : int{
 		return 300;
 	}
-
-	protected function getOpenSound() : Sound{
-		return new BarrelOpenSound();
-	}
-
-	protected function getCloseSound() : Sound{
-		return new BarrelCloseSound();
-	}
-
-	protected function playAnimationVisual(Position $position, bool $isOpen) : void{
-		$world = $position->getWorld();
-		$block = $world->getBlock($position);
-		if($block instanceof Barrel){
-			$world->setBlock($position, $block->setOpen($isOpen));
-		}
-	}
 }

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,26 +35,20 @@ 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; //TODO: rename this (BC break)
-	protected SignText $backText;
+	protected SignText $text;
 	private bool $waxed = false;
 
 	protected ?int $editorEntityRuntimeId = null;
@@ -69,7 +63,6 @@ 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;
 	}
 
@@ -78,7 +71,6 @@ 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();
 		}
@@ -91,7 +83,6 @@ 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);
 	}
@@ -108,11 +99,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){
@@ -120,7 +111,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();
 		}
@@ -136,11 +127,11 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		}
 	}
 
-	private function doSignChange(SignText $newText, Player $player, Item $item, bool $frontFace) : bool{
-		$ev = new SignChangeEvent($this, $player, $newText, $frontFace);
+	private function doSignChange(SignText $newText, Player $player, Item $item) : bool{
+		$ev = new SignChangeEvent($this, $player, $newText);
 		$ev->call();
 		if(!$ev->isCancelled()){
-			$this->setFaceText($frontFace, $ev->getNewText());
+			$this->text = $ev->getNewText();
 			$this->position->getWorld()->setBlock($this->position, $this);
 			$item->pop();
 			return true;
@@ -149,9 +140,8 @@ abstract class BaseSign extends Transparent implements WoodMaterial{
 		return false;
 	}
 
-	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)){
+	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)){
 			$this->position->getWorld()->addSound($this->position, new InkSacUseSound());
 			return true;
 		}
@@ -170,7 +160,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;
 		}
@@ -178,8 +168,6 @@ 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,
@@ -188,82 +176,40 @@ 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() !== $text->getBaseColor()->toARGB() &&
-				$this->doSignChange(new SignText($text->getLines(), $color, $text->isGlowing()), $player, $item, $frontFace)
+				$color->toARGB() !== $this->text->getBaseColor()->toARGB() &&
+				$this->doSignChange(new SignText($this->text->getLines(), $color, $this->text->isGlowing()), $player, $item)
 			){
 				$this->position->getWorld()->addSound($this->position, new DyeUseSound());
 				return true;
 			}
 		}elseif(match($item->getTypeId()){
-			ItemTypeIds::INK_SAC => $this->changeSignGlowingState(false, $player, $item, $frontFace),
-			ItemTypeIds::GLOW_INK_SAC => $this->changeSignGlowingState(true, $player, $item, $frontFace),
+			ItemTypeIds::INK_SAC => $this->changeSignGlowingState(false, $player, $item),
+			ItemTypeIds::GLOW_INK_SAC => $this->changeSignGlowingState(true, $player, $item),
 			ItemTypeIds::HONEYCOMB => $this->wax($player, $item),
 			default => false
 		}){
 			return true;
 		}
 
-		$player->openSignEditor($this->position, $frontFace);
+		$player->openSignEditor($this->position);
 
 		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;
 	}
 
-	/**
-	 * @deprecated
-	 * @see self::setFaceText()
-	 * @return $this
-	 */
+	/** @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.
 	 */
@@ -288,21 +234,13 @@ 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 updateFaceText(Player $author, bool $frontFace, SignText $text) : bool{
+	public function updateText(Player $author, SignText $text) : bool{
 		$size = 0;
 		foreach($text->getLines() as $line){
 			$size += strlen($line);
@@ -310,16 +248,15 @@ 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()), $oldText->getBaseColor(), $oldText->isGlowing()), $frontFace);
+		}, $text->getLines()), $this->text->getBaseColor(), $this->text->isGlowing()));
 		if($this->waxed || $this->editorEntityRuntimeId !== $author->getId()){
 			$ev->cancel();
 		}
 		$ev->call();
 		if(!$ev->isCancelled()){
-			$this->setFaceText($frontFace, $ev->getNewText());
+			$this->setText($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

@@ -424,7 +424,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 +436,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 +524,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 +533,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 +770,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 +793,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 +914,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 +945,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/BrewingStand.php

@@ -23,24 +23,20 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\inventory\window\BrewingStandInventoryWindow;
 use pocketmine\block\tile\BrewingStand as TileBrewingStand;
 use pocketmine\block\utils\BrewingStandSlot;
-use pocketmine\block\utils\Container;
-use pocketmine\block\utils\ContainerTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
-use pocketmine\inventory\Inventory;
+use pocketmine\item\Item;
 use pocketmine\math\Axis;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
 use pocketmine\player\Player;
-use pocketmine\world\Position;
 use function array_key_exists;
 use function spl_object_id;
 
-class BrewingStand extends Transparent implements Container{
-	use ContainerTrait;
+class BrewingStand extends Transparent{
 
 	/**
 	 * @var BrewingStandSlot[]
@@ -55,17 +51,17 @@ class BrewingStand extends Transparent implements Container{
 	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;
 	}
 
@@ -99,8 +95,15 @@ class BrewingStand extends Transparent implements Container{
 		return $this;
 	}
 
-	protected function newMenu(Player $player, Inventory $inventory, Position $position) : BrewingStandInventoryWindow{
-		return new BrewingStandInventoryWindow($player, $inventory, $position);
+	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())){
+				$player->setCurrentWindow($stand->getInventory());
+			}
+		}
+
+		return true;
 	}
 
 	public function onScheduledUpdate() : void{

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

@@ -23,9 +23,9 @@ declare(strict_types=1);
 
 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;
@@ -40,7 +40,6 @@ use pocketmine\entity\projectile\SplashPotion;
 use pocketmine\event\block\CampfireCookEvent;
 use pocketmine\event\entity\EntityDamageByBlockEvent;
 use pocketmine\event\entity\EntityDamageEvent;
-use pocketmine\inventory\Inventory;
 use pocketmine\item\Durable;
 use pocketmine\item\enchantment\VanillaEnchantments;
 use pocketmine\item\Item;
@@ -76,7 +75,7 @@ class Campfire extends Transparent implements Lightable, HorizontalFacing{
 	 * @deprecated This was added by mistake. It can't be relied on as the inventory won't be initialized if this block
 	 * has never been set in the world.
 	 */
-	protected ?Inventory $inventory = null;
+	protected CampfireInventory $inventory;
 
 	/**
 	 * @var int[] slot => ticks
@@ -96,8 +95,7 @@ class Campfire extends Transparent implements Lightable, HorizontalFacing{
 			$this->inventory = $tile->getInventory();
 			$this->cookingTimes = $tile->getCookingTimes();
 		}else{
-			$this->inventory = null;
-			$this->cookingTimes = [];
+			$this->inventory = new CampfireInventory($this->position);
 		}
 
 		return $this;
@@ -129,19 +127,19 @@ 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)];
 	}
 
 	/**
 	 * @deprecated This was added by mistake. It can't be relied on as the inventory won't be initialized if this block
 	 * has never been set in the world.
 	 */
-	public function getInventory() : ?Inventory{
+	public function getInventory() : CampfireInventory{
 		return $this->inventory;
 	}
 
@@ -173,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();
@@ -204,11 +202,10 @@ class Campfire extends Transparent implements Lightable, HorizontalFacing{
 			return true;
 		}
 
-		$inventory = $this->inventory;
-		if($inventory !== null && $this->position->getWorld()->getServer()->getCraftingManager()->getFurnaceRecipeManager($this->getFurnaceType())->match($item) !== null){
+		if($this->position->getWorld()->getServer()->getCraftingManager()->getFurnaceRecipeManager($this->getFurnaceType())->match($item) !== null){
 			$ingredient = clone $item;
 			$ingredient->setCount(1);
-			if(count($inventory->addItem($ingredient)) === 0){
+			if(count($this->inventory->addItem($ingredient)) === 0){
 				$item->pop();
 				$this->position->getWorld()->addSound($this->position, new ItemFrameAddItemSound());
 				return true;
@@ -243,8 +240,8 @@ class Campfire extends Transparent implements Lightable, HorizontalFacing{
 	}
 
 	public function onScheduledUpdate() : void{
-		if($this->lit && ($inventory = $this->inventory) !== null){
-			$items = $inventory->getContents();
+		if($this->lit){
+			$items = $this->inventory->getContents();
 			$furnaceType = $this->getFurnaceType();
 			$maxCookDuration = $furnaceType->getCookDurationTicks();
 			foreach($items as $slot => $item){
@@ -262,7 +259,7 @@ class Campfire extends Transparent implements Lightable, HorizontalFacing{
 						continue;
 					}
 
-					$inventory->setItem($slot, VanillaItems::AIR());
+					$this->inventory->setItem($slot, VanillaItems::AIR());
 					$this->setCookingTime($slot, 0);
 					$this->position->getWorld()->dropItem($this->position->add(0.5, 1, 0.5), $ev->getResult());
 				}

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

@@ -23,17 +23,19 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\inventory\window\CartographyTableInventoryWindow;
-use pocketmine\block\utils\MenuAccessor;
-use pocketmine\block\utils\MenuAccessorTrait;
+use pocketmine\block\inventory\CartographyTableInventory;
+use pocketmine\item\Item;
+use pocketmine\math\Vector3;
 use pocketmine\player\Player;
-use pocketmine\world\Position;
 
-final class CartographyTable extends Opaque implements MenuAccessor{
-	use MenuAccessorTrait;
+final class CartographyTable extends Opaque{
 
-	protected function newMenu(Player $player, Position $position) : CartographyTableInventoryWindow{
-		return new CartographyTableInventoryWindow($player, $position);
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($player !== null){
+			$player->setCurrentWindow(new CartographyTableInventory($this->position));
+		}
+
+		return true;
 	}
 
 	public function getFuelTime() : int{

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,8 +58,4 @@ 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,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\item\Item;
@@ -36,16 +35,16 @@ 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,15 +63,6 @@ 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()));
-	}
-
-	protected function getFacingDegrees() : float{
-		return match($this->facing){
-			HorizontalFacingOption::SOUTH => 0,
-			HorizontalFacingOption::WEST => 90,
-			HorizontalFacingOption::NORTH => 180,
-			HorizontalFacingOption::EAST => 270,
-		};
+			(($supportBlock instanceof WallHangingSign || $supportBlock instanceof CeilingEdgesHangingSign) && Facing::axis($supportBlock->getFacing()) === Facing::axis($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

@@ -23,203 +23,74 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\inventory\window\BlockInventoryWindow;
-use pocketmine\block\inventory\window\DoubleChestInventoryWindow;
 use pocketmine\block\tile\Chest as TileChest;
-use pocketmine\block\utils\AnimatedContainerLike;
-use pocketmine\block\utils\AnimatedContainerLikeTrait;
-use pocketmine\block\utils\ChestPairHalf;
-use pocketmine\block\utils\Container;
-use pocketmine\block\utils\ContainerTrait;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\SupportType;
 use pocketmine\event\block\ChestPairEvent;
-use pocketmine\inventory\CombinedInventoryProxy;
-use pocketmine\inventory\Inventory;
+use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
-use pocketmine\network\mcpe\protocol\BlockEventPacket;
-use pocketmine\network\mcpe\protocol\types\BlockPosition;
-use pocketmine\player\InventoryWindow;
+use pocketmine\math\Vector3;
 use pocketmine\player\Player;
-use pocketmine\world\Position;
-use pocketmine\world\sound\ChestCloseSound;
-use pocketmine\world\sound\ChestOpenSound;
-use pocketmine\world\sound\Sound;
-use function assert;
 
-class Chest extends Transparent implements AnimatedContainerLike, Container, HorizontalFacing{
-	use AnimatedContainerLikeTrait;
-	use ContainerTrait;
+class Chest extends Transparent implements HorizontalFacing{
 	use FacesOppositePlacingPlayerTrait;
 
-	protected ?ChestPairHalf $pairHalf = null;
-
-	public function getPairHalf() : ?ChestPairHalf{ return $this->pairHalf; }
-
-	public function setPairHalf(?ChestPairHalf $pairHalf) : self{
-		$this->pairHalf = $pairHalf;
-		return $this;
-	}
-
-	public function readStateFromWorld() : Block{
-		parent::readStateFromWorld();
-		$tile = $this->position->getWorld()->getTile($this->position);
-
-		$this->pairHalf = null;
-		if($tile instanceof TileChest && ($pairXZ = $tile->getPairXZ()) !== null){
-			[$pairX, $pairZ] = $pairXZ;
-			foreach(ChestPairHalf::cases() as $pairSide){
-				$pairDirection = $pairSide->getOtherHalfSide($this->facing);
-				$pairPosition = $this->position->getSide($pairDirection);
-				if($pairPosition->getFloorX() === $pairX && $pairPosition->getFloorZ() === $pairZ){
-					$this->pairHalf = $pairSide;
-					break;
-				}
-			}
-		}
-
-		return $this;
-	}
-
-	public function writeStateToWorld() : void{
-		parent::writeStateToWorld();
-		$tile = $this->position->getWorld()->getTile($this->position);
-		assert($tile instanceof TileChest);
-
-		//TODO: this should probably use relative coordinates instead of absolute, for portability
-		if($this->pairHalf !== null){
-			$pairDirection = $this->pairHalf->getOtherHalfSide($this->facing);
-			$pairPosition = $this->position->getSide($pairDirection);
-			$pairXZ = [$pairPosition->getFloorX(), $pairPosition->getFloorZ()];
-		}else{
-			$pairXZ = null;
-		}
-		$tile->setPairXZ($pairXZ);
-	}
-
 	protected function recalculateCollisionBoxes() : array{
 		//these are slightly bigger than in PC
-		$facing = $this->facing->toFacing();
-		$box = AxisAlignedBB::one()
-			->squashedCopy(Facing::axis($facing), 0.025)
-			->trimmedCopy(Facing::UP, 0.05);
-		$pairSide = $this->pairHalf?->getOtherHalfSide($this->facing);
-		return [$pairSide !== null ?
-			$box->trimmedCopy(Facing::opposite($pairSide), 0.025) :
-			$box->squashedCopy(Facing::axis(Facing::rotateY($facing, true)), 0.025)
-		];
+		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;
 	}
 
-	private function getPossiblePair(ChestPairHalf $pairSide) : ?Chest{
-		$pair = $this->getSide($pairSide->getOtherHalfSide($this->facing));
-		return $pair->hasSameTypeId($this) && $pair instanceof Chest && $pair->getFacing() === $this->facing ? $pair : null;
-	}
-
-	public function getOtherHalf() : ?Chest{
-		return $this->pairHalf !== null && ($pair = $this->getPossiblePair($this->pairHalf)) !== null && $pair->pairHalf === $this->pairHalf->opposite() ? $pair : null;
-	}
-
 	public function onPostPlace() : void{
-		//Not sure if this vanilla behaviour is intended, but a chest facing north or west will try to pair on the left
-		//side first, while a chest facing south or east will try the right side first.
-		$order = match($this->facing){
-			HorizontalFacingOption::NORTH, HorizontalFacingOption::WEST => [ChestPairHalf::LEFT, ChestPairHalf::RIGHT],
-			HorizontalFacingOption::SOUTH, HorizontalFacingOption::EAST => [ChestPairHalf::RIGHT, ChestPairHalf::LEFT]
-		};
 		$world = $this->position->getWorld();
-		foreach($order as $pairSide){
-			$possiblePair = $this->getPossiblePair($pairSide);
-			if($possiblePair !== null && $possiblePair->pairHalf === null){
-				[$left, $right] = $pairSide === ChestPairHalf::LEFT ? [$this, $possiblePair] : [$possiblePair, $this];
-				$ev = new ChestPairEvent($left, $right);
-				if(!$ev->isCancelled() && $world->getBlock($this->position)->isSameState($this) && $world->getBlock($possiblePair->position)->isSameState($possiblePair)){
-					$world->setBlock($this->position, $this->setPairHalf($pairSide));
-					$world->setBlock($possiblePair->position, $possiblePair->setPairHalf($pairSide->opposite()));
-					break;
+		$tile = $world->getTile($this->position);
+		if($tile instanceof TileChest){
+			foreach([false, true] as $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);
+					if($pair instanceof TileChest && !$pair->isPaired()){
+						[$left, $right] = $clockwise ? [$c, $this] : [$this, $c];
+						$ev = new ChestPairEvent($left, $right);
+						$ev->call();
+						if(!$ev->isCancelled() && $world->getBlock($this->position)->hasSameTypeId($this) && $world->getBlock($c->position)->hasSameTypeId($c)){
+							$pair->pairWith($tile);
+							$tile->pairWith($pair);
+							break;
+						}
+					}
 				}
 			}
 		}
 	}
 
-	public function onNearbyBlockChange() : void{
-		//TODO: If the pair chunk isn't loaded, a block update of an adjacent block in loaded terrain could cause the
-		//chest to become unpaired. However, this is not unique to chests (think wall connections). Probably we
-		//should defer updates in chunks whose neighbours are not loaded?
-		if($this->pairHalf !== null && $this->getOtherHalf() === null){
-			$this->position->getWorld()->setBlock($this->position, $this->setPairHalf(null));
-		}
-	}
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($player instanceof Player){
 
-	public function isOpeningObstructed() : bool{
-		foreach([$this, $this->getOtherHalf()] as $chest){
-			if($chest !== null && !$chest->getSide(Facing::UP)->isTransparent()){
-				return true;
+			$chest = $this->position->getWorld()->getTile($this->position);
+			if($chest instanceof TileChest){
+				if(
+					!$this->getSide(Facing::UP)->isTransparent() ||
+					(($pair = $chest->getPair()) !== null && !$pair->getBlock()->getSide(Facing::UP)->isTransparent()) ||
+					!$chest->canOpenWith($item->getCustomName())
+				){
+					return true;
+				}
+
+				$player->setCurrentWindow($chest->getInventory());
 			}
 		}
-		return false;
-	}
 
-	protected function getTile() : ?TileChest{
-		$tile = $this->position->getWorld()->getTile($this->position);
-		return $tile instanceof TileChest ? $tile : null;
-	}
-
-	public function getInventory() : ?Inventory{
-		$thisInventory = $this->getTile()?->getRealInventory();
-		if($thisInventory === null){
-			return null;
-		}
-		$pairInventory = $this->getOtherHalf()?->getTile()?->getRealInventory();
-		if($pairInventory === null){
-			return $thisInventory;
-		}
-
-		[$left, $right] = $this->pairHalf === ChestPairHalf::LEFT ? [$thisInventory, $pairInventory] : [$pairInventory, $thisInventory];
-		return new CombinedInventoryProxy([$left, $right]);
-	}
-
-	protected function newMenu(Player $player, Inventory $inventory, Position $position) : InventoryWindow{
-		$pair = $this->getOtherHalf();
-		if($pair === null){
-			return new BlockInventoryWindow($player, $inventory, $position);
-		}
-		[$left, $right] = $this->pairHalf === ChestPairHalf::LEFT ? [$this, $pair] : [$pair, $this];
-		return new DoubleChestInventoryWindow($player, $inventory, $left->position, $right->position);
+		return true;
 	}
 
 	public function getFuelTime() : int{
 		return 300;
 	}
-
-	protected function getOpenSound() : Sound{
-		return new ChestOpenSound();
-	}
-
-	protected function getCloseSound() : Sound{
-		return new ChestCloseSound();
-	}
-
-	protected function playAnimationVisual(Position $position, bool $isOpen) : void{
-		//event ID is always 1 for a chest
-		//TODO: we probably shouldn't be sending a packet directly here, but it doesn't fit anywhere into existing systems
-		$position->getWorld()->broadcastPacketToViewers($position, BlockEventPacket::create(BlockPosition::fromVector3($position), 1, $isOpen ? 1 : 0));
-	}
-
-	protected function doAnimationEffects(bool $isOpen) : void{
-		$this->playAnimationVisual($this->position, $isOpen);
-		$this->playAnimationSound($this->position, $isOpen);
-
-		$pair = $this->getOtherHalf();
-		if($pair !== null){
-			$this->playAnimationVisual($pair->position, $isOpen);
-			$this->playAnimationSound($pair->position, $isOpen);
-		}
-	}
 }

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

@@ -23,17 +23,19 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\inventory\window\CraftingTableInventoryWindow;
-use pocketmine\block\utils\MenuAccessor;
-use pocketmine\block\utils\MenuAccessorTrait;
+use pocketmine\block\inventory\CraftingTableInventory;
+use pocketmine\item\Item;
+use pocketmine\math\Vector3;
 use pocketmine\player\Player;
-use pocketmine\world\Position;
 
-class CraftingTable extends Opaque implements MenuAccessor{
-	use MenuAccessorTrait;
+class CraftingTable extends Opaque{
 
-	protected function newMenu(Player $player, Position $position) : CraftingTableInventoryWindow{
-		return new CraftingTableInventoryWindow($player, $position);
+	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));
+		}
+
+		return true;
 	}
 
 	public function getFuelTime() : int{

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

@@ -23,27 +23,31 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\inventory\window\EnchantingTableInventoryWindow;
-use pocketmine\block\utils\MenuAccessor;
-use pocketmine\block\utils\MenuAccessorTrait;
+use pocketmine\block\inventory\EnchantInventory;
 use pocketmine\block\utils\SupportType;
+use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
 use pocketmine\player\Player;
-use pocketmine\world\Position;
 
-class EnchantingTable extends Transparent implements MenuAccessor{
-	use MenuAccessorTrait;
+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;
 	}
 
-	protected function newMenu(Player $player, Position $position) : EnchantingTableInventoryWindow{
-		return new EnchantingTableInventoryWindow($player, $position);
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($player instanceof Player){
+			//TODO lock
+
+			$player->setCurrentWindow(new EnchantInventory($this->position));
+		}
+
+		return true;
 	}
 }

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

@@ -23,31 +23,18 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\inventory\window\BlockInventoryWindow;
+use pocketmine\block\inventory\EnderChestInventory;
 use pocketmine\block\tile\EnderChest as TileEnderChest;
-use pocketmine\block\utils\AnimatedContainerLike;
-use pocketmine\block\utils\AnimatedContainerLikeTrait;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\MenuAccessorTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
-use pocketmine\network\mcpe\protocol\BlockEventPacket;
-use pocketmine\network\mcpe\protocol\types\BlockPosition;
+use pocketmine\math\Vector3;
 use pocketmine\player\Player;
-use pocketmine\world\Position;
-use pocketmine\world\sound\EnderChestCloseSound;
-use pocketmine\world\sound\EnderChestOpenSound;
-use pocketmine\world\sound\Sound;
 
-class EnderChest extends Transparent implements AnimatedContainerLike, HorizontalFacing{
-	use AnimatedContainerLikeTrait {
-		onViewerAdded as private traitOnViewerAdded;
-		onViewerRemoved as private traitOnViewerRemoved;
-	}
-	use MenuAccessorTrait;
+class EnderChest extends Transparent implements HorizontalFacing{
 	use FacesOppositePlacingPlayerTrait;
 
 	public function getLightLevel() : int{
@@ -56,19 +43,23 @@ class EnderChest extends Transparent implements AnimatedContainerLike, Horizonta
 
 	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 isOpeningObstructed() : bool{
-		return !$this->getSide(Facing::UP)->isTransparent();
-	}
+	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()){
+				$enderChest->setViewerCount($enderChest->getViewerCount() + 1);
+				$player->setCurrentWindow(new EnderChestInventory($this->position, $player->getEnderInventory()));
+			}
+		}
 
-	protected function newMenu(Player $player, Position $position) : BlockInventoryWindow{
-		return new BlockInventoryWindow($player, $player->getEnderInventory(), $position);
+		return true;
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
@@ -80,43 +71,4 @@ class EnderChest extends Transparent implements AnimatedContainerLike, Horizonta
 	public function isAffectedBySilkTouch() : bool{
 		return true;
 	}
-
-	protected function getViewerCount() : int{
-		$enderChest = $this->position->getWorld()->getTile($this->position);
-		if(!$enderChest instanceof TileEnderChest){
-			return 0;
-		}
-		return $enderChest->getViewerCount();
-	}
-
-	private function updateViewerCount(int $amount) : void{
-		$enderChest = $this->position->getWorld()->getTile($this->position);
-		if($enderChest instanceof TileEnderChest){
-			$enderChest->setViewerCount($enderChest->getViewerCount() + $amount);
-		}
-	}
-
-	protected function getOpenSound() : Sound{
-		return new EnderChestOpenSound();
-	}
-
-	protected function getCloseSound() : Sound{
-		return new EnderChestCloseSound();
-	}
-
-	protected function playAnimationVisual(Position $position, bool $isOpen) : void{
-		//event ID is always 1 for a chest
-		//TODO: we probably shouldn't be sending a packet directly here, but it doesn't fit anywhere into existing systems
-		$position->getWorld()->broadcastPacketToViewers($position, BlockEventPacket::create(BlockPosition::fromVector3($position), 1, $isOpen ? 1 : 0));
-	}
-
-	public function onViewerAdded() : void{
-		$this->updateViewerCount(1);
-		$this->traitOnViewerAdded();
-	}
-
-	public function onViewerRemoved() : void{
-		$this->traitOnViewerRemoved();
-		$this->updateViewerCount(-1);
-	}
 }

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,8 +48,4 @@ 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

@@ -23,24 +23,19 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\inventory\window\FurnaceInventoryWindow;
 use pocketmine\block\tile\Furnace as TileFurnace;
-use pocketmine\block\utils\Container;
-use pocketmine\block\utils\ContainerTrait;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
 use pocketmine\block\utils\HorizontalFacing;
 use pocketmine\block\utils\Lightable;
 use pocketmine\block\utils\LightableTrait;
 use pocketmine\crafting\FurnaceType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
-use pocketmine\inventory\Inventory;
-use pocketmine\player\InventoryWindow;
+use pocketmine\item\Item;
+use pocketmine\math\Vector3;
 use pocketmine\player\Player;
-use pocketmine\world\Position;
 use function mt_rand;
 
-class Furnace extends Opaque implements Container, Lightable, HorizontalFacing{
-	use ContainerTrait;
+class Furnace extends Opaque implements Lightable, HorizontalFacing{
 	use FacesOppositePlacingPlayerTrait;
 	use LightableTrait;
 
@@ -52,7 +47,7 @@ class Furnace extends Opaque implements Container, Lightable, HorizontalFacing{
 	}
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 		$w->bool($this->lit);
 	}
 
@@ -64,8 +59,15 @@ class Furnace extends Opaque implements Container, Lightable, HorizontalFacing{
 		return $this->lit ? 13 : 0;
 	}
 
-	protected function newMenu(Player $player, Inventory $inventory, Position $position) : InventoryWindow{
-		return new FurnaceInventoryWindow($player, $inventory, $position, $this->furnaceType);
+	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())){
+				$player->setCurrentWindow($furnace->getInventory());
+			}
+		}
+
+		return true;
 	}
 
 	public function onScheduledUpdate() : void{

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

@@ -23,38 +23,32 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\inventory\window\HopperInventoryWindow;
-use pocketmine\block\utils\Container;
-use pocketmine\block\utils\ContainerTrait;
+use pocketmine\block\tile\Hopper as TileHopper;
 use pocketmine\block\utils\PoweredByRedstone;
 use pocketmine\block\utils\PoweredByRedstoneTrait;
 use pocketmine\block\utils\SupportType;
 use pocketmine\data\runtime\RuntimeDataDescriber;
-use pocketmine\inventory\Inventory;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\player\InventoryWindow;
 use pocketmine\player\Player;
 use pocketmine\world\BlockTransaction;
-use pocketmine\world\Position;
 
-class Hopper extends Transparent implements Container, PoweredByRedstone{
-	use ContainerTrait;
+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");
 		}
@@ -64,16 +58,16 @@ class Hopper extends Transparent implements Container, 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,
@@ -81,14 +75,21 @@ class Hopper extends Transparent implements Container, 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);
 	}
 
-	protected function newMenu(Player $player, Inventory $inventory, Position $position) : InventoryWindow{
-		return new HopperInventoryWindow($player, $inventory, $position);
+	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
+				$player->setCurrentWindow($tile->getInventory());
+			}
+			return true;
+		}
+		return false;
 	}
 
 	public function onScheduledUpdate() : void{

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

@@ -23,19 +23,21 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\inventory\window\LoomInventoryWindow;
+use pocketmine\block\inventory\LoomInventory;
 use pocketmine\block\utils\FacesOppositePlacingPlayerTrait;
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\MenuAccessor;
-use pocketmine\block\utils\MenuAccessorTrait;
+use pocketmine\item\Item;
+use pocketmine\math\Vector3;
 use pocketmine\player\Player;
-use pocketmine\world\Position;
 
-final class Loom extends Opaque implements HorizontalFacing, MenuAccessor{
+final class Loom extends Opaque implements HorizontalFacing{
 	use FacesOppositePlacingPlayerTrait;
-	use MenuAccessorTrait;
 
-	protected function newMenu(Player $player, Position $position) : LoomInventoryWindow{
-		return new LoomInventoryWindow($player, $position);
+	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;
+		}
+		return false;
 	}
 }

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);
 	}
 }

src/block/PinkPetals.php

@@ -25,7 +25,6 @@ namespace pocketmine\block;
 
 use pocketmine\block\utils\BlockEventHelper;
 use pocketmine\block\utils\HorizontalFacing;
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\StaticSupportTrait;
 use pocketmine\data\runtime\RuntimeDataDescriber;
@@ -48,7 +47,7 @@ class PinkPetals extends Flowable implements HorizontalFacing{
 	protected int $count = self::MIN_COUNT;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->facing);
+		$w->horizontalFacing($this->facing);
 		$w->boundedIntAuto(self::MIN_COUNT, self::MAX_COUNT, $this->count);
 	}
 
@@ -71,21 +70,21 @@ class PinkPetals extends Flowable implements HorizontalFacing{
 		return $supportBlock->hasTypeTag(BlockTypeTags::DIRT) || $supportBlock->hasTypeTag(BlockTypeTags::MUD);
 	}
 
-	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 instanceof PinkPetals && $blockReplace->count < self::MAX_COUNT) || $this->supportedWhenPlacedAt($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 instanceof PinkPetals && $blockReplace->count < self::MAX_COUNT){
 			$this->count = $blockReplace->count + 1;
 			$this->facing = $blockReplace->facing;
 		}elseif($player !== null){
-			$this->facing = HorizontalFacingOption::fromFacing(Facing::opposite($player->getHorizontalFacing()));
+			$this->facing = Facing::opposite($player->getHorizontalFacing());
 		}
 		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){
 			$grew = false;
 			if($this->count < self::MAX_COUNT){

src/block/PitcherCrop.php

@@ -54,10 +54,10 @@ final class PitcherCrop extends Flowable implements Ageable{
 		$heightTrim = $this->age === 0 ? 13 : 11;
 		return [
 			AxisAlignedBB::one()
-				->trimmedCopy(Facing::UP, $heightTrim / 16)
-				->squashedCopy(Axis::X, $widthTrim / 16)
-				->squashedCopy(Axis::Z, $widthTrim / 16)
-				->extendedCopy(Facing::DOWN, 1 / 16) //presumably this is to correct for farmland being 15/16 of a block tall
+				->trim(Facing::UP, $heightTrim / 16)
+				->squash(Axis::X, $widthTrim / 16)
+				->squash(Axis::Z, $widthTrim / 16)
+				->extend(Facing::DOWN, 1 / 16) //presumably this is to correct for farmland being 15/16 of a block tall
 		];
 	}
 
@@ -85,7 +85,7 @@ final class PitcherCrop extends Flowable implements Ageable{
 		return BlockEventHelper::grow($this, (clone $this)->setAge($this->age + 1), $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;

src/block/PotionCauldron.php

@@ -27,7 +27,6 @@ use pocketmine\block\tile\Cauldron as TileCauldron;
 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\CauldronEmptyPotionSound;
@@ -95,7 +94,7 @@ final class PotionCauldron extends FillableCauldron{
 		}
 	}
 
-	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::LINGERING_POTION, ItemTypeIds::POTION, ItemTypeIds::SPLASH_POTION => $this->addFillLevelsOrMix(self::POTION_FILL_AMOUNT, $item, VanillaItems::GLASS_BOTTLE(), $returnedItems),
 			ItemTypeIds::GLASS_BOTTLE => $this->potionItem === null ? null : $this->removeFillLevels(self::POTION_FILL_AMOUNT, $item, clone $this->potionItem, $returnedItems),

src/block/PressurePlate.php

@@ -57,7 +57,7 @@ abstract class PressurePlate extends Transparent{
 		return [];
 	}
 
-	public function getSupportType(Facing $facing) : SupportType{
+	public function getSupportType(int $facing) : SupportType{
 		return SupportType::NONE;
 	}
 
@@ -83,10 +83,10 @@ abstract class PressurePlate extends Transparent{
 	 */
 	protected function getActivationBox() : AxisAlignedBB{
 		return AxisAlignedBB::one()
-			->squashedCopy(Axis::X, 1 / 8)
-			->squashedCopy(Axis::Z, 1 / 8)
-			->trimmedCopy(Facing::UP, 3 / 4)
-			->offsetCopy($this->position->x, $this->position->y, $this->position->z);
+			->squash(Axis::X, 1 / 8)
+			->squash(Axis::Z, 1 / 8)
+			->trim(Facing::UP, 3 / 4)
+			->offset($this->position->x, $this->position->y, $this->position->z);
 	}
 
 	/**

src/block/Pumpkin.php

@@ -23,21 +23,21 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\HorizontalFacingOption;
 use pocketmine\item\Item;
 use pocketmine\item\Shears;
 use pocketmine\item\VanillaItems;
 use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
 use pocketmine\player\Player;
+use function in_array;
 
 class Pumpkin extends Opaque{
 
-	public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
-		if($item instanceof Shears && ($hzFacing = HorizontalFacingOption::tryFromFacing($face)) !== null){
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($item instanceof Shears && in_array($face, Facing::HORIZONTAL, true)){
 			$item->applyDamage(1);
 			$world = $this->position->getWorld();
-			$world->setBlock($this->position, VanillaBlocks::CARVED_PUMPKIN()->setFacing($hzFacing));
+			$world->setBlock($this->position, VanillaBlocks::CARVED_PUMPKIN()->setFacing($face));
 			$world->dropItem($this->position->add(0.5, 0.5, 0.5), VanillaItems::PUMPKIN_SEEDS()->setCount(1));
 			return true;
 		}

src/block/Rail.php

@@ -24,16 +24,18 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\RailConnectionInfo;
-use pocketmine\block\utils\RailShape;
+use pocketmine\data\bedrock\block\BlockLegacyMetadata;
 use pocketmine\data\runtime\RuntimeDataDescriber;
 use pocketmine\math\Facing;
+use function array_keys;
+use function implode;
 
 class Rail extends BaseRail{
 
-	private RailShape $railShape = RailShape::FLAT_AXIS_Z;
+	private int $railShape = BlockLegacyMetadata::RAIL_STRAIGHT_NORTH_SOUTH;
 
 	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
-		$w->enum($this->railShape);
+		$w->railShape($this->railShape);
 	}
 
 	protected function setShapeFromConnections(array $connections) : void{
@@ -41,11 +43,11 @@ class Rail extends BaseRail{
 		if($railShape === null){
 			throw new \InvalidArgumentException("No rail shape matches these connections");
 		}
-		$this->railShape = RailShape::from($railShape);
+		$this->railShape = $railShape;
 	}
 
 	protected function getCurrentShapeConnections() : array{
-		return RailConnectionInfo::CURVE_CONNECTIONS[$this->railShape->value] ?? RailConnectionInfo::CONNECTIONS[$this->railShape->value];
+		return RailConnectionInfo::CURVE_CONNECTIONS[$this->railShape] ?? RailConnectionInfo::CONNECTIONS[$this->railShape];
 	}
 
 	protected function getPossibleConnectionDirectionsOneConstraint(int $constraint) : array{
@@ -58,8 +60,8 @@ class Rail extends BaseRail{
 				Facing::WEST,
 				Facing::EAST
 			] as $d){
-				if($constraint !== $d->value){
-					$possible[$d->value] = true;
+				if($constraint !== $d){
+					$possible[$d] = true;
 				}
 			}
 		}
@@ -67,10 +69,13 @@ class Rail extends BaseRail{
 		return $possible;
 	}
 
-	public function getShape() : RailShape{ return $this->railShape; }
+	public function getShape() : int{ return $this->railShape; }
 
 	/** @return $this */
-	public function setShape(RailShape $shape) : self{
+	public function setShape(int $shape) : self{
+		if(!isset(RailConnectionInfo::CONNECTIONS[$shape]) && !isset(RailConnectionInfo::CURVE_CONNECTIONS[$shape])){
+			throw new \InvalidArgumentException("Invalid shape, must be one of " . implode(", ", [...array_keys(RailConnectionInfo::CONNECTIONS), ...array_keys(RailConnectionInfo::CURVE_CONNECTIONS)]));
+		}
 		$this->railShape = $shape;
 		return $this;
 	}