Implement glow lichen (#5401)

src/block/BlockTypeIds.php

@@ -717,8 +717,9 @@ final class BlockTypeIds{
 	public const FLOWERING_AZALEA_LEAVES = 10687;
 	public const REINFORCED_DEEPSLATE = 10688;
 	public const CAVE_VINES = 10689;
+	public const GLOW_LICHEN = 10690;
 
-	public const FIRST_UNUSED_BLOCK_ID = 10690;
+	public const FIRST_UNUSED_BLOCK_ID = 10691;
 
 	private static int $nextDynamicId = self::FIRST_UNUSED_BLOCK_ID;
 

src/block/GlowLichen.php

@@ -0,0 +1,284 @@
+<?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\utils\SupportType;
+use pocketmine\data\runtime\RuntimeDataDescriber;
+use pocketmine\event\block\BlockSpreadEvent;
+use pocketmine\item\Fertilizer;
+use pocketmine\item\Item;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\World;
+use function array_key_first;
+use function count;
+use function shuffle;
+
+class GlowLichen extends Transparent{
+
+	/** @var int[] */
+	protected array $faces = [];
+
+	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
+		$w->facingFlags($this->faces);
+	}
+
+	/** @return int[] */
+	public function getFaces() : array{ return $this->faces; }
+
+	public function hasFace(int $face) : bool{
+		return isset($this->faces[$face]);
+	}
+
+	/**
+	 * @param int[] $faces
+	 * @return $this
+	 */
+	public function setFaces(array $faces) : self{
+		$uniqueFaces = [];
+		foreach($faces as $face){
+			Facing::validate($face);
+			$uniqueFaces[$face] = $face;
+		}
+		$this->faces = $uniqueFaces;
+		return $this;
+	}
+
+	/** @return $this */
+	public function setFace(int $face, bool $value) : self{
+		Facing::validate($face);
+		if($value){
+			$this->faces[$face] = $face;
+		}else{
+			unset($this->faces[$face]);
+		}
+		return $this;
+	}
+
+	public function getLightLevel() : int{
+		return 7;
+	}
+
+	public function isSolid() : bool{
+		return false;
+	}
+
+	/**
+	 * @return AxisAlignedBB[]
+	 */
+	protected function recalculateCollisionBoxes() : array{
+		return [];
+	}
+
+	public function getSupportType(int $facing) : SupportType{
+		return SupportType::NONE();
+	}
+
+	public function canBeReplaced() : bool{
+		return true;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$this->faces = $blockReplace instanceof GlowLichen ? $blockReplace->faces : [];
+		$availableFaces = $this->getAvailableFaces();
+
+		if(count($availableFaces) === 0){
+			return false;
+		}
+
+		$opposite = Facing::opposite($face);
+		$placedFace = isset($availableFaces[$opposite]) ? $opposite : array_key_first($availableFaces);
+		$this->faces[$placedFace] = $placedFace;
+
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onNearbyBlockChange() : void{
+		$changed = false;
+
+		foreach($this->faces as $face){
+			if(!$this->getSide($face)->getSupportType(Facing::opposite($face))->equals(SupportType::FULL())){
+				unset($this->faces[$face]);
+				$changed = true;
+			}
+		}
+
+		if($changed){
+			$world = $this->position->getWorld();
+			if(count($this->faces) === 0){
+				$world->useBreakOn($this->position);
+			}else{
+				$world->setBlock($this->position, $this);
+			}
+		}
+	}
+
+	private function getSpreadBlock(Block $replace, int $spreadFace) : ?Block{
+		if($replace instanceof self && $replace->hasSameTypeId($this)){
+			if($replace->hasFace($spreadFace)){
+				return null;
+			}
+			$result = $replace;
+		}elseif($replace->getTypeId() === BlockTypeIds::AIR){
+			$result = VanillaBlocks::GLOW_LICHEN();
+		}else{
+			//TODO: if this is a water block, generate a waterlogged block
+			return null;
+		}
+		return $result->setFace($spreadFace, true);
+	}
+
+	private function spread(World $world, Vector3 $replacePos, int $spreadFace) : bool{
+		$supportBlock = $world->getBlock($replacePos->getSide($spreadFace));
+		$supportFace = Facing::opposite($spreadFace);
+
+		if(!$supportBlock->getSupportType($supportFace)->equals(SupportType::FULL())){
+			return false;
+		}
+
+		$replacedBlock = $supportBlock->getSide($supportFace);
+		$replacementBlock = $this->getSpreadBlock($replacedBlock, Facing::opposite($supportFace));
+		if($replacementBlock === null){
+			return false;
+		}
+
+		$ev = new BlockSpreadEvent($replacedBlock, $this, $replacementBlock);
+		$ev->call();
+		if(!$ev->isCancelled()){
+			$world->setBlock($replacedBlock->getPosition(), $ev->getNewState());
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * @phpstan-return \Generator<int, int, void, void>
+	 */
+	private static function getShuffledSpreadFaces(int $sourceFace) : \Generator{
+		$skipAxis = Facing::axis($sourceFace);
+
+		$faces = Facing::ALL;
+		shuffle($faces);
+		foreach($faces as $spreadFace){
+			if(Facing::axis($spreadFace) !== $skipAxis){
+				yield $spreadFace;
+			}
+		}
+	}
+
+	private function spreadAroundSupport(int $sourceFace) : bool{
+		$world = $this->position->getWorld();
+
+		$supportPos = $this->position->getSide($sourceFace);
+		foreach(self::getShuffledSpreadFaces($sourceFace) as $spreadFace){
+			$replacePos = $supportPos->getSide($spreadFace);
+			if($this->spread($world, $replacePos, Facing::opposite($spreadFace))){
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	private function spreadAdjacentToSupport(int $sourceFace) : bool{
+		$world = $this->position->getWorld();
+
+		foreach(self::getShuffledSpreadFaces($sourceFace) as $spreadFace){
+			$replacePos = $this->position->getSide($spreadFace);
+			if($this->spread($world, $replacePos, $sourceFace)){
+				return true;
+			}
+		}
+		return false;
+	}
+
+	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;
+			}
+		}
+
+		return false;
+	}
+
+	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);
+
+			$spreadMethods = [
+				$this->spreadAroundSupport(...),
+				$this->spreadAdjacentToSupport(...),
+				$this->spreadWithinSelf(...),
+			];
+			shuffle($spreadMethods);
+
+			foreach($shuffledFaces as $sourceFace){
+				foreach($spreadMethods as $spreadMethod){
+					if($spreadMethod($sourceFace)){
+						$item->pop();
+						break 2;
+					}
+				}
+			}
+
+			return true;
+		}
+		return false;
+	}
+
+	public function getDrops(Item $item) : array{
+		if(($item->getBlockToolType() & BlockToolType::SHEARS) !== 0){
+			return $this->getDropsForCompatibleTool($item);
+		}
+
+		return [];
+	}
+
+	public function getFlameEncouragement() : int{
+		return 15;
+	}
+
+	public function getFlammability() : int{
+		return 100;
+	}
+
+	/**
+	 * @return array<int, int> $faces
+	 */
+	private function getAvailableFaces() : array{
+		$faces = [];
+		foreach(Facing::ALL as $face){
+			if(!$this->hasFace($face) && $this->getSide($face)->getSupportType(Facing::opposite($face))->equals(SupportType::FULL())){
+				$faces[$face] = $face;
+			}
+		}
+		return $faces;
+	}
+}

src/block/VanillaBlocks.php

@@ -417,6 +417,7 @@ use function mb_strtolower;
  * @method static ItemFrame GLOWING_ITEM_FRAME()
  * @method static GlowingObsidian GLOWING_OBSIDIAN()
  * @method static Glowstone GLOWSTONE()
+ * @method static GlowLichen GLOW_LICHEN()
  * @method static Opaque GOLD()
  * @method static GoldOre GOLD_ORE()
  * @method static Opaque GRANITE()
@@ -864,6 +865,7 @@ final class VanillaBlocks{
 		self::register("glass_pane", new GlassPane(new BID(Ids::GLASS_PANE), "Glass Pane", $glassBreakInfo));
 		self::register("glowing_obsidian", new GlowingObsidian(new BID(Ids::GLOWING_OBSIDIAN), "Glowing Obsidian", new Info(BreakInfo::pickaxe(10.0, ToolTier::DIAMOND(), 50.0))));
 		self::register("glowstone", new Glowstone(new BID(Ids::GLOWSTONE), "Glowstone", new Info(BreakInfo::pickaxe(0.3))));
+		self::register("glow_lichen", new GlowLichen(new BID(Ids::GLOW_LICHEN), "Glow Lichen", new Info(BreakInfo::axe(0.2, null, 0.2))));
 		self::register("gold", new Opaque(new BID(Ids::GOLD), "Gold Block", new Info(BreakInfo::pickaxe(3.0, ToolTier::IRON(), 30.0))));
 
 		$grassBreakInfo = BreakInfo::shovel(0.6);

src/data/bedrock/block/BlockLegacyMetadata.php

@@ -38,6 +38,13 @@ final class BlockLegacyMetadata{
 	public const CORAL_VARIANT_FIRE = 3;
 	public const CORAL_VARIANT_HORN = 4;
 
+	public const MULTI_FACE_DIRECTION_FLAG_DOWN = 0x01;
+	public const MULTI_FACE_DIRECTION_FLAG_UP = 0x02;
+	public const MULTI_FACE_DIRECTION_FLAG_SOUTH = 0x04;
+	public const MULTI_FACE_DIRECTION_FLAG_WEST = 0x08;
+	public const MULTI_FACE_DIRECTION_FLAG_NORTH = 0x10;
+	public const MULTI_FACE_DIRECTION_FLAG_EAST = 0x20;
+
 	public const MUSHROOM_BLOCK_ALL_PORES = 0;
 	public const MUSHROOM_BLOCK_CAP_NORTHWEST_CORNER = 1;
 	public const MUSHROOM_BLOCK_CAP_NORTH_SIDE = 2;

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

@@ -79,6 +79,7 @@ use pocketmine\block\Froglight;
 use pocketmine\block\FrostedIce;
 use pocketmine\block\Furnace;
 use pocketmine\block\GlazedTerracotta;
+use pocketmine\block\GlowLichen;
 use pocketmine\block\HayBale;
 use pocketmine\block\Hopper;
 use pocketmine\block\ItemFrame;
@@ -1030,6 +1031,10 @@ final class BlockObjectToStateSerializer implements BlockStateSerializer{
 				->writeInt(StateNames::AGE, $block->getAge());
 		});
 		$this->map(Blocks::FURNACE(), fn(Furnace $block) => Helper::encodeFurnace($block, Ids::FURNACE, Ids::LIT_FURNACE));
+		$this->map(Blocks::GLOW_LICHEN(), function(GlowLichen $block) : Writer{
+			return Writer::create(Ids::GLOW_LICHEN)
+				->writeFacingFlags($block->getFaces());
+		});
 		$this->map(Blocks::GLOWING_ITEM_FRAME(), fn(ItemFrame $block) => Helper::encodeItemFrame($block, Ids::GLOW_FRAME));
 		$this->map(Blocks::GRANITE(), fn() => Helper::encodeStone(StringValues::STONE_TYPE_GRANITE));
 		$this->map(Blocks::GRANITE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab3($block, StringValues::STONE_SLAB_TYPE_3_GRANITE));

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

@@ -28,6 +28,7 @@ use pocketmine\block\utils\CoralType;
 use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\SlabType;
 use pocketmine\block\utils\WallConnectionType;
+use pocketmine\data\bedrock\block\BlockLegacyMetadata;
 use pocketmine\data\bedrock\block\BlockStateData;
 use pocketmine\data\bedrock\block\BlockStateDeserializeException;
 use pocketmine\data\bedrock\block\BlockStateNames;
@@ -134,6 +135,29 @@ final class BlockStateReader{
 		]);
 	}
 
+	/**
+	 * @return int[]
+	 * @phpstan-return array<int, int>
+	 */
+	public function readFacingFlags() : array{
+		$result = [];
+		$flags = $this->readBoundedInt(BlockStateNames::MULTI_FACE_DIRECTION_BITS, 0, 63);
+		foreach([
+			BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_DOWN => Facing::DOWN,
+			BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_UP => Facing::UP,
+			BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_NORTH => Facing::NORTH,
+			BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_SOUTH => Facing::SOUTH,
+			BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_WEST => Facing::WEST,
+			BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_EAST => Facing::EAST
+		] as $flag => $facing){
+			if(($flags & $flag) !== 0){
+				$result[$facing] = $facing;
+			}
+		}
+
+		return $result;
+	}
+
 	/** @throws BlockStateDeserializeException */
 	public function readEndRodFacingDirection() : int{
 		$result = $this->readFacingDirection();

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

@@ -827,6 +827,7 @@ final class BlockStateToObjectDeserializer implements BlockStateDeserializer{
 				->setFacing($in->readHorizontalFacing())
 				->setLit(false);
 		});
+		$this->map(Ids::GLOW_LICHEN, fn(Reader $in) => Blocks::GLOW_LICHEN()->setFaces($in->readFacingFlags()));
 		$this->map(Ids::GLOW_FRAME, fn(Reader $in) => Helper::decodeItemFrame(Blocks::GLOWING_ITEM_FRAME(), $in));
 		$this->map(Ids::GOLDEN_RAIL, function(Reader $in) : Block{
 			return Blocks::POWERED_RAIL()

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

@@ -29,6 +29,7 @@ use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\SlabType;
 use pocketmine\block\utils\WallConnectionType;
 use pocketmine\block\utils\WoodType;
+use pocketmine\data\bedrock\block\BlockLegacyMetadata;
 use pocketmine\data\bedrock\block\BlockStateData;
 use pocketmine\data\bedrock\block\BlockStateNames;
 use pocketmine\data\bedrock\block\BlockStateSerializeException;
@@ -39,6 +40,7 @@ use pocketmine\nbt\tag\ByteTag;
 use pocketmine\nbt\tag\IntTag;
 use pocketmine\nbt\tag\StringTag;
 use pocketmine\nbt\tag\Tag;
+use pocketmine\utils\AssumptionFailedError;
 
 final class BlockStateWriter{
 
@@ -88,6 +90,28 @@ final class BlockStateWriter{
 		return $this;
 	}
 
+	/**
+	 * @param int[] $faces
+	 * @phpstan-param array<int, int> $faces
+	 * @return $this
+	 */
+	public function writeFacingFlags(array $faces) : self{
+		$result = 0;
+		foreach($faces as $face){
+			$result |= match($face){
+				Facing::DOWN => BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_DOWN,
+				Facing::UP => BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_UP,
+				Facing::NORTH => BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_NORTH,
+				Facing::SOUTH => BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_SOUTH,
+				Facing::WEST => BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_WEST,
+				Facing::EAST => BlockLegacyMetadata::MULTI_FACE_DIRECTION_FLAG_EAST,
+				default => throw new AssumptionFailedError("Unhandled face $face")
+			};
+		}
+
+		return $this->writeInt(BlockStateNames::MULTI_FACE_DIRECTION_BITS, $result);
+	}
+
 	/** @return $this */
 	public function writeEndRodFacingDirection(int $value) : self{
 		//end rods are stupid in bedrock and have everything except up/down the wrong way round

src/data/runtime/RuntimeDataDescriber.php

@@ -36,6 +36,11 @@ interface RuntimeDataDescriber extends RuntimeEnumDescriber{
 
 	public function horizontalFacing(int &$facing) : void;
 
+	/**
+	 * @param int[] $faces
+	 */
+	public function facingFlags(array &$faces) : void;
+
 	/**
 	 * @param int[] $faces
 	 */

src/data/runtime/RuntimeDataReader.php

@@ -86,6 +86,20 @@ final class RuntimeDataReader implements RuntimeDataDescriber{
 		};
 	}
 
+	/**
+	 * @param int[] $faces
+	 */
+	public function facingFlags(array &$faces) : void{
+		$result = [];
+		foreach(Facing::ALL as $facing){
+			if($this->readBool()){
+				$result[$facing] = $facing;
+			}
+		}
+
+		$faces = $result;
+	}
+
 	/**
 	 * @param int[] $faces
 	 */

src/data/runtime/RuntimeDataSizeCalculator.php

@@ -56,12 +56,12 @@ final class RuntimeDataSizeCalculator implements RuntimeDataDescriber{
 		$this->addBits(2);
 	}
 
-	/**
-	 * @inheritDoc
-	 */
+	public function facingFlags(array &$faces) : void{
+		$this->addBits(count(Facing::ALL));
+	}
+
 	public function horizontalFacingFlags(array &$faces) : void{
 		$this->addBits(count(Facing::HORIZONTAL));
-		// TODO: Implement horizontalFacingFlags() method.
 	}
 
 	public function facing(int &$facing) : void{

src/data/runtime/RuntimeDataWriter.php

@@ -85,6 +85,16 @@ final class RuntimeDataWriter implements RuntimeDataDescriber{
 		});
 	}
 
+	/**
+	 * @param int[] $faces
+	 */
+	public function facingFlags(array &$faces) : void{
+		$uniqueFaces = array_flip($faces);
+		foreach(Facing::ALL as $facing){
+			$this->writeBool(isset($uniqueFaces[$facing]));
+		}
+	}
+
 	/**
 	 * @param int[] $faces
 	 */

src/item/StringToItemParser.php

@@ -647,6 +647,7 @@ final class StringToItemParser extends StringToTParser{
 		$result->registerBlock("glowingobsidian", fn() => Blocks::GLOWING_OBSIDIAN());
 		$result->registerBlock("glowstone", fn() => Blocks::GLOWSTONE());
 		$result->registerBlock("glowstone_block", fn() => Blocks::GLOWSTONE());
+		$result->registerBlock("glow_lichen", fn() => Blocks::GLOW_LICHEN());
 		$result->registerBlock("gold", fn() => Blocks::GOLD());
 		$result->registerBlock("gold_block", fn() => Blocks::GOLD());
 		$result->registerBlock("gold_ore", fn() => Blocks::GOLD_ORE());