Implemented bells

src/block/Bell.php

@@ -0,0 +1,162 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block;
+
+use pocketmine\block\tile\Bell as TileBell;
+use pocketmine\block\utils\BellAttachmentType;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\block\utils\HorizontalFacingTrait;
+use pocketmine\block\utils\InvalidBlockStateException;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\utils\AssumptionFailedError;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\sound\BellRingSound;
+
+final class Bell extends Transparent{
+	private const BELL_RINGING_REPEAT_TICKS = 20;
+
+	use HorizontalFacingTrait;
+
+	private BellAttachmentType $attachmentType;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		$this->attachmentType = BellAttachmentType::FLOOR();
+		parent::__construct($idInfo, $name, $breakInfo);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->setFacing(BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03));
+
+		$attachmentType = [
+			BlockLegacyMetadata::BELL_ATTACHMENT_FLOOR => BellAttachmentType::FLOOR(),
+			BlockLegacyMetadata::BELL_ATTACHMENT_CEILING => BellAttachmentType::CEILING(),
+			BlockLegacyMetadata::BELL_ATTACHMENT_ONE_WALL => BellAttachmentType::ONE_WALL(),
+			BlockLegacyMetadata::BELL_ATTACHMENT_TWO_WALLS => BellAttachmentType::TWO_WALLS()
+		][($stateMeta >> 2) & 0b11] ?? null;
+		if($attachmentType === null){
+			throw new InvalidBlockStateException("No such attachment type");
+		}
+		$this->setAttachmentType($attachmentType);
+	}
+
+	public function writeStateToMeta() : int{
+		$attachmentTypeMeta = [
+			BellAttachmentType::FLOOR()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_FLOOR,
+			BellAttachmentType::CEILING()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_CEILING,
+			BellAttachmentType::ONE_WALL()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_ONE_WALL,
+			BellAttachmentType::TWO_WALLS()->id() => BlockLegacyMetadata::BELL_ATTACHMENT_TWO_WALLS
+		][$this->getAttachmentType()->id()] ?? null;
+		if($attachmentTypeMeta === null){
+			throw new AssumptionFailedError("Mapping should cover all cases");
+		}
+		return BlockDataSerializer::writeLegacyHorizontalFacing($this->getFacing()) | ($attachmentTypeMeta << 2);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function getAttachmentType() : BellAttachmentType{ return $this->attachmentType; }
+
+	/** @return $this */
+	public function setAttachmentType(BellAttachmentType $attachmentType) : self{
+		$this->attachmentType = $attachmentType;
+		return $this;
+	}
+
+	private function canBeSupportedBy(Block $block) : bool{
+		//TODO: this isn't the actual logic, but it's the closest approximation we can support for now
+		return $block->isSolid();
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($face === Facing::UP){
+			if(!$this->canBeSupportedBy($tx->fetchBlock($this->pos->down()))){
+				return false;
+			}
+			if($player !== null){
+				$this->setFacing(Facing::opposite($player->getHorizontalFacing()));
+			}
+			$this->setAttachmentType(BellAttachmentType::FLOOR());
+		}elseif($face === Facing::DOWN){
+			if(!$this->canBeSupportedBy($tx->fetchBlock($this->pos->up()))){
+				return false;
+			}
+			$this->setAttachmentType(BellAttachmentType::CEILING());
+		}else{
+			$this->setFacing($face);
+			if($this->canBeSupportedBy($tx->fetchBlock($this->pos->getSide(Facing::opposite($face))))){
+				$this->setAttachmentType(BellAttachmentType::ONE_WALL());
+			}else{
+				return false;
+			}
+			if($this->canBeSupportedBy($tx->fetchBlock($this->pos->getSide($face)))){
+				$this->setAttachmentType(BellAttachmentType::TWO_WALLS());
+			}
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(
+			($this->attachmentType->equals(BellAttachmentType::CEILING()) && !$this->canBeSupportedBy($this->getSide(Facing::UP))) ||
+			($this->attachmentType->equals(BellAttachmentType::FLOOR()) && !$this->canBeSupportedBy($this->getSide(Facing::DOWN))) ||
+			($this->attachmentType->equals(BellAttachmentType::ONE_WALL()) && !$this->canBeSupportedBy($this->getSide(Facing::opposite($this->facing)))) ||
+			($this->attachmentType->equals(BellAttachmentType::TWO_WALLS()) && (!$this->canBeSupportedBy($this->getSide($this->facing)) || !$this->canBeSupportedBy($this->getSide(Facing::opposite($this->facing)))))
+		){
+			$this->pos->getWorld()->useBreakOn($this->pos);
+		}
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player !== null){
+			$faceHit = Facing::opposite($player->getHorizontalFacing());
+			if($this->attachmentType->equals(BellAttachmentType::CEILING())){
+				$this->ring($faceHit);
+			}
+			if($this->attachmentType->equals(BellAttachmentType::FLOOR()) && Facing::axis($faceHit) === Facing::axis($this->facing)){
+				$this->ring($faceHit);
+			}
+			if(
+				($this->attachmentType->equals(BellAttachmentType::ONE_WALL()) || $this->attachmentType->equals(BellAttachmentType::TWO_WALLS())) &&
+				($faceHit === Facing::rotateY($this->facing, false) || $faceHit === Facing::rotateY($this->facing, true))
+			){
+				$this->ring($faceHit);
+			}
+		}
+
+		return true;
+	}
+
+	public function ring(int $faceHit) : void{
+		$this->pos->getWorld()->addSound($this->pos, new BellRingSound());
+		$tile = $this->pos->getWorld()->getTile($this->pos);
+		if($tile instanceof TileBell){
+			$this->pos->getWorld()->broadcastPacketToViewers($this->pos, $tile->createFakeUpdatePacket($faceHit));
+		}
+	}
+}

src/block/BlockFactory.php

@@ -31,6 +31,7 @@ use pocketmine\block\tile\Banner as TileBanner;
 use pocketmine\block\tile\Barrel as TileBarrel;
 use pocketmine\block\tile\Beacon as TileBeacon;
 use pocketmine\block\tile\Bed as TileBed;
+use pocketmine\block\tile\Bell as TileBell;
 use pocketmine\block\tile\BrewingStand as TileBrewingStand;
 use pocketmine\block\tile\Chest as TileChest;
 use pocketmine\block\tile\Comparator as TileComparator;
@@ -118,6 +119,7 @@ class BlockFactory{
 		$this->register(new Bedrock(new BID(Ids::BEDROCK, 0), "Bedrock", BlockBreakInfo::indestructible()));
 
 		$this->register(new Beetroot(new BID(Ids::BEETROOT_BLOCK, 0), "Beetroot Block", BlockBreakInfo::instant()));
+		$this->register(new Bell(new BID(Ids::BELL, 0, null, TileBell::class), "Bell", new BlockBreakInfo(5.0, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel())));
 		$this->register(new BlueIce(new BID(Ids::BLUE_ICE, 0), "Blue Ice", new BlockBreakInfo(2.8, BlockToolType::PICKAXE)));
 		$this->register(new BoneBlock(new BID(Ids::BONE_BLOCK, 0), "Bone Block", new BlockBreakInfo(2.0, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel())));
 		$this->register(new Bookshelf(new BID(Ids::BOOKSHELF, 0), "Bookshelf", new BlockBreakInfo(1.5, BlockToolType::AXE)));
@@ -542,7 +544,6 @@ class BlockFactory{
 		));
 
 		//region --- auto-generated TODOs for bedrock-1.11.0 ---
-		//TODO: minecraft:bell
 		//TODO: minecraft:blast_furnace
 		//TODO: minecraft:bubble_column
 		//TODO: minecraft:campfire

src/block/VanillaBlocks.php

@@ -65,6 +65,7 @@ use function assert;
  * @method static Bed BED()
  * @method static Bedrock BEDROCK()
  * @method static Beetroot BEETROOTS()
+ * @method static Bell BELL()
  * @method static WoodenButton BIRCH_BUTTON()
  * @method static WoodenDoor BIRCH_DOOR()
  * @method static WoodenFence BIRCH_FENCE()
@@ -626,6 +627,7 @@ final class VanillaBlocks{
 		self::register("bed", $factory->get(26, 0));
 		self::register("bedrock", $factory->get(7, 0));
 		self::register("beetroots", $factory->get(244, 0));
+		self::register("bell", $factory->get(461, 0));
 		self::register("birch_button", $factory->get(396, 0));
 		self::register("birch_door", $factory->get(194, 0));
 		self::register("birch_fence", $factory->get(85, 2));

src/block/tile/Bell.php

@@ -0,0 +1,86 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block\tile;
+
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\math\Facing;
+use pocketmine\nbt\tag\CompoundTag;
+use pocketmine\network\mcpe\protocol\BlockActorDataPacket;
+use pocketmine\network\mcpe\protocol\types\CacheableNbt;
+
+final class Bell extends Spawnable{
+	public const TAG_DIRECTION = "Direction"; //TAG_Int
+	public const TAG_RINGING = "Ringing"; //TAG_Byte
+	public const TAG_TICKS = "Ticks"; //TAG_Int
+
+	private bool $ringing = false;
+	private int $facing = Facing::NORTH;
+	private int $ticks = 0;
+
+	public function isRinging() : bool{ return $this->ringing; }
+
+	public function setRinging(bool $ringing) : void{ $this->ringing = $ringing; }
+
+	public function getFacing() : int{ return $this->facing; }
+
+	public function setFacing(int $facing) : void{ $this->facing = $facing; }
+
+	public function getTicks() : int{ return $this->ticks; }
+
+	public function setTicks(int $ticks) : void{ $this->ticks = $ticks; }
+
+	protected function addAdditionalSpawnData(CompoundTag $nbt) : void{
+		$nbt->setByte(self::TAG_RINGING, $this->ringing ? 1 : 0);
+		$nbt->setInt(self::TAG_DIRECTION, $this->facing);
+		$nbt->setInt(self::TAG_TICKS, $this->ticks);
+	}
+
+	public function readSaveData(CompoundTag $nbt) : void{
+		$this->ringing = $nbt->getByte(self::TAG_RINGING, 0) !== 0;
+		$this->facing = $nbt->getInt(self::TAG_DIRECTION, Facing::NORTH);
+		$this->ticks = $nbt->getInt(self::TAG_TICKS, 0);
+	}
+
+	protected function writeSaveData(CompoundTag $nbt) : void{
+		$nbt->setByte(self::TAG_RINGING, $this->ringing ? 1 : 0);
+		$nbt->setInt(self::TAG_DIRECTION, $this->facing);
+		$nbt->setInt(self::TAG_TICKS, $this->ticks);
+	}
+
+	/**
+	 * TODO: HACK!
+	 * Creates a BlockActorDataPacket that triggers the ringing animation on a bell block.
+	 *
+	 * Bedrock team overcomplicated making bells ring when they implemented this; this would have been better and much
+	 * simpler as a BlockEventPacket. It's simpler to implement bells with this hack than to follow Mojang's complicated
+	 * mess.
+	 */
+	public function createFakeUpdatePacket(int $bellHitFace) : BlockActorDataPacket{
+		$nbt = $this->getSpawnCompound();
+		$nbt->setByte(self::TAG_RINGING, 1);
+		$nbt->setInt(self::TAG_DIRECTION, BlockDataSerializer::writeLegacyHorizontalFacing($bellHitFace));
+		$nbt->setInt(self::TAG_TICKS, 0);
+		return BlockActorDataPacket::create($this->pos->getFloorX(), $this->pos->getFloorY(), $this->pos->getFloorZ(), new CacheableNbt($nbt));
+	}
+}

src/block/tile/TileFactory.php

@@ -53,6 +53,7 @@ final class TileFactory{
 		$this->register(Banner::class, ["Banner", "minecraft:banner"]);
 		$this->register(Beacon::class, ["Beacon", "minecraft:beacon"]);
 		$this->register(Bed::class, ["Bed", "minecraft:bed"]);
+		$this->register(Bell::class, ["Bell", "minecraft:bell"]);
 		$this->register(BrewingStand::class, ["BrewingStand", "minecraft:brewing_stand"]);
 		$this->register(Chest::class, ["Chest", "minecraft:chest"]);
 		$this->register(Comparator::class, ["Comparator", "minecraft:comparator"]);
@@ -70,7 +71,6 @@ final class TileFactory{
 		$this->register(Sign::class, ["Sign", "minecraft:sign"]);
 		$this->register(Skull::class, ["Skull", "minecraft:skull"]);
 
-		//TODO: Bell
 		//TODO: BlastFurnace
 		//TODO: Campfire
 		//TODO: Cauldron

src/block/utils/BellAttachmentType.php

@@ -0,0 +1,49 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\block\utils;
+
+use pocketmine\utils\EnumTrait;
+
+/**
+ * This doc-block is generated automatically, do not modify it manually.
+ * This must be regenerated whenever registry members are added, removed or changed.
+ * @see \pocketmine\utils\RegistryUtils::_generateMethodAnnotations()
+ *
+ * @method static BellAttachmentType CEILING()
+ * @method static BellAttachmentType FLOOR()
+ * @method static BellAttachmentType ONE_WALL()
+ * @method static BellAttachmentType TWO_WALLS()
+ */
+final class BellAttachmentType{
+	use EnumTrait;
+
+	protected static function setup() : void{
+		self::registerAll(
+			new self("ceiling"),
+			new self("floor"),
+			new self("one_wall"),
+			new self("two_walls")
+		);
+	}
+}

src/world/sound/BellRingSound.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+*/
+
+declare(strict_types=1);
+
+namespace pocketmine\world\sound;
+
+use pocketmine\math\Vector3;
+use pocketmine\network\mcpe\protocol\LevelSoundEventPacket;
+
+final class BellRingSound implements Sound{
+
+	public function encode(?Vector3 $pos) : array{
+		return [LevelSoundEventPacket::create(LevelSoundEventPacket::SOUND_BLOCK_BELL_HIT, $pos)];
+	}
+}