Prepare 5.33.2 release (#6804)

if the prediction was a fail, we can assume that the client didn't do anything visual on its end,
which avoids the need to resend blocks.
This fixes block lag when towering as discussed in #6803.

The more general issue in #6803 remains unresolved (that the server's block resyncing may overwrite
additional client side predictions if it places a block before the server's resync for the initial
placement arrives), but that's more complicated to fix and I'm not convinced on the correct method
to resolve it yet.

In any case, this change nets a decent improvement for everyone, regardless.

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

build/generate-block-serializer-consts.php

@@ -29,6 +29,9 @@ use pocketmine\data\bedrock\block\BlockStateStringValues;
 use pocketmine\data\bedrock\block\BlockTypeNames;
 use pocketmine\errorhandler\ErrorToExceptionHandler;
 use pocketmine\nbt\NbtException;
+use pocketmine\nbt\tag\ByteTag;
+use pocketmine\nbt\tag\IntTag;
+use pocketmine\nbt\tag\StringTag;
 use pocketmine\network\mcpe\convert\BlockStateDictionary;
 use pocketmine\utils\AssumptionFailedError;
 use pocketmine\utils\Utils;
@@ -78,6 +81,9 @@ function generateBlockPaletteReport(array $states) : BlockPaletteReport{
 		$name = $stateData->getName();
 		$result->seenTypes[$name] = $name;
 		foreach(Utils::stringifyKeys($stateData->getStates()) as $k => $v){
+			if(!$v instanceof ByteTag && !$v instanceof IntTag && !$v instanceof StringTag){
+				throw new AssumptionFailedError("Assumed all state tags should be TAG_Byte, TAG_Int or TAG_String, but found $k ($v) on block $name");
+			}
 			$result->seenStateValues[$k][$v->getValue()] = $v->getValue();
 			asort($result->seenStateValues[$k]);
 		}

changelogs/5.33.md

@@ -133,3 +133,15 @@ Released 31st August 2025.
 
 ## Fixes
 - Fixed banners placed in prior versions getting their tiles deleted (due to missing `Type` tags).
+
+# 5.33.2
+Released 16th September 2025.
+
+## General
+- PHP 8.4 has now been added to the test matrix.
+
+## Fixes
+- Fixed PHP 8.4 deprecation notice in `AsyncGeneratorExecutor`.
+- Fixed inventory windows breaking if a window is sent while the player has the chat window open (e.g. quickly pressing E followed by / could trigger this).
+- Fixed `BlockBreakEvent` being called twice in creative if cancelled.
+- Reduced block lag when towering and other situations where the placed block might intersect with the player's AABB. Block lag may still appear on higher latency clients - this is still being worked on.

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": "2.1.25",
       "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/VersionInfo.php

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

src/block/AmethystCluster.php

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

src/block/Anvil.php

@@ -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),