Merge 'minor-next' into 'major-next'

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

Author: pmmp-admin-bot[bot]

src/block/BlockTypeIds.php

@@ -786,8 +786,9 @@ private function __construct(){
 	public const RESIN_BRICKS = 10756;
 	public const RESIN_CLUMP = 10757;
 	public const CHISELED_RESIN_BRICKS = 10758;
+	public const RESPAWN_ANCHOR = 10759;
 
-	public const FIRST_UNUSED_BLOCK_ID = 10759;
+	public const FIRST_UNUSED_BLOCK_ID = 10760;
 
 	private static int $nextDynamicId = self::FIRST_UNUSED_BLOCK_ID;
 

src/block/RespawnAnchor.php

@@ -0,0 +1,123 @@
+<?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\data\runtime\RuntimeDataDescriber;
+use pocketmine\event\block\BlockPreExplodeEvent;
+use pocketmine\event\player\PlayerRespawnAnchorUseEvent;
+use pocketmine\item\Item;
+use pocketmine\item\ItemTypeIds;
+use pocketmine\lang\KnownTranslationFactory;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\utils\TextFormat;
+use pocketmine\world\Explosion;
+use pocketmine\world\Position;
+use pocketmine\world\sound\RespawnAnchorChargeSound;
+use pocketmine\world\sound\RespawnAnchorSetSpawnSound;
+
+final class RespawnAnchor extends Opaque{
+	private const MIN_CHARGES = 0;
+	private const MAX_CHARGES = 4;
+
+	private int $charges = self::MIN_CHARGES;
+
+	protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
+		$w->boundedIntAuto(self::MIN_CHARGES, self::MAX_CHARGES, $this->charges);
+	}
+
+	public function getCharges() : int{
+		return $this->charges;
+	}
+
+	/** @return $this */
+	public function setCharges(int $charges) : self{
+		if($charges < self::MIN_CHARGES || $charges > self::MAX_CHARGES){
+			throw new \InvalidArgumentException("Charges must be between " . self::MIN_CHARGES . " and " . self::MAX_CHARGES . ", given: $charges");
+		}
+		$this->charges = $charges;
+		return $this;
+	}
+
+	public function getLightLevel() : int{
+		return $this->charges > 0 ? ($this->charges * 4) - 1 : 0;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
+		if($item->getTypeId() === ItemTypeIds::fromBlockTypeId(BlockTypeIds::GLOWSTONE) && $this->charges < self::MAX_CHARGES){
+			$this->position->getWorld()->setBlock($this->position, $this->setCharges($this->charges + 1));
+			$this->position->getWorld()->addSound($this->position, new RespawnAnchorChargeSound());
+			return true;
+		}
+
+		if($this->charges > self::MIN_CHARGES){
+			if($player === null){
+				return false;
+			}
+
+			$ev = new PlayerRespawnAnchorUseEvent($player, $this, PlayerRespawnAnchorUseEvent::ACTION_EXPLODE);
+			$ev->call();
+			if($ev->isCancelled()){
+				return false;
+			}
+
+			switch($ev->getAction()){
+				case PlayerRespawnAnchorUseEvent::ACTION_EXPLODE:
+					$this->explode($player);
+					return false;
+
+				case PlayerRespawnAnchorUseEvent::ACTION_SET_SPAWN:
+					if($player->getSpawn() !== null && $player->getSpawn()->equals($this->position)){
+						return true;
+					}
+
+					$player->setSpawn($this->position);
+					$this->position->getWorld()->addSound($this->position, new RespawnAnchorSetSpawnSound());
+					$player->sendMessage(KnownTranslationFactory::tile_respawn_anchor_respawnSet()->prefix(TextFormat::GRAY));
+					return true;
+			}
+		}
+		return false;
+	}
+
+	private function explode(?Player $player) : void{
+		$ev = new BlockPreExplodeEvent($this, 5, $player);
+		$ev->setIncendiary(true);
+
+		$ev->call();
+		if($ev->isCancelled()){
+			return;
+		}
+
+		$this->position->getWorld()->setBlock($this->position, VanillaBlocks::AIR());
+
+		$explosion = new Explosion(Position::fromObject($this->position->add(0.5, 0.5, 0.5), $this->position->getWorld()), $ev->getRadius(), $this);
+		$explosion->setFireChance($ev->getFireChance());
+
+		if($ev->isBlockBreaking()){
+			$explosion->explodeA();
+		}
+		$explosion->explodeB();
+	}
+}

src/block/VanillaBlocks.php

@@ -694,6 +694,7 @@
  * @method static Stair RESIN_BRICK_STAIRS()
  * @method static Wall RESIN_BRICK_WALL()
  * @method static ResinClump RESIN_CLUMP()
+ * @method static RespawnAnchor RESPAWN_ANCHOR()
  * @method static DoublePlant ROSE_BUSH()
  * @method static Sand SAND()
  * @method static Opaque SANDSTONE()
@@ -1647,6 +1648,8 @@ public function getLightLevel() : int{ return 10;}
 		self::register("warped_roots", fn(BID $id) => new NetherRoots($id, "Warped Roots", $netherRootsInfo));
 
 		self::register("chain", fn(BID $id) => new Chain($id, "Chain", new Info(BreakInfo::pickaxe(5.0, ToolTier::WOOD, 30.0))));
+
+		self::register("respawn_anchor", fn(BID $id) => new RespawnAnchor($id, "Respawn Anchor", new Info(BreakInfo::pickaxe(50.0, ToolTier::DIAMOND, 6000.0))));
 	}
 
 	private static function registerBlocksR17() : void{

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

@@ -122,6 +122,7 @@
 use pocketmine\block\RedstoneTorch;
 use pocketmine\block\RedstoneWire;
 use pocketmine\block\ResinClump;
+use pocketmine\block\RespawnAnchor;
 use pocketmine\block\RuntimeBlockStateRegistry;
 use pocketmine\block\Sapling;
 use pocketmine\block\SeaPickle;
@@ -1753,6 +1754,10 @@ private function registerSerializers() : void{
 			return Writer::create(Ids::RESIN_CLUMP)
 				->writeFacingFlags($block->getFaces());
 		});
+		$this->map(Blocks::RESPAWN_ANCHOR(), function(RespawnAnchor $block) : Writer{
+			return Writer::create(Ids::RESPAWN_ANCHOR)
+				->writeInt(StateNames::RESPAWN_ANCHOR_CHARGE, $block->getCharges());
+		});
 		$this->map(Blocks::ROSE_BUSH(), fn(DoublePlant $block) => Helper::encodeDoublePlant($block, Writer::create(Ids::ROSE_BUSH)));
 		$this->mapSlab(Blocks::SANDSTONE_SLAB(), Ids::SANDSTONE_SLAB, Ids::SANDSTONE_DOUBLE_SLAB);
 		$this->mapStairs(Blocks::SANDSTONE_STAIRS(), Ids::SANDSTONE_STAIRS);

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

@@ -1717,6 +1717,10 @@ private function registerDeserializers() : void{
 		$this->mapStairs(Ids::RESIN_BRICK_STAIRS, fn() => Blocks::RESIN_BRICK_STAIRS());
 		$this->map(Ids::RESIN_BRICK_WALL, fn(Reader $in) => Helper::decodeWall(Blocks::RESIN_BRICK_WALL(), $in));
 		$this->map(Ids::RESIN_CLUMP, fn(Reader $in) => Blocks::RESIN_CLUMP()->setFaces($in->readFacingFlags()));
+		$this->map(Ids::RESPAWN_ANCHOR, function(Reader $in) : Block{
+			return Blocks::RESPAWN_ANCHOR()
+				->setCharges($in->readBoundedInt(StateNames::RESPAWN_ANCHOR_CHARGE, 0, 4));
+		});
 		$this->mapSlab(Ids::SANDSTONE_SLAB, Ids::SANDSTONE_DOUBLE_SLAB, fn() => Blocks::SANDSTONE_SLAB());
 		$this->mapStairs(Ids::SANDSTONE_STAIRS, fn() => Blocks::SANDSTONE_STAIRS());
 		$this->map(Ids::SANDSTONE_WALL, fn(Reader $in) => Helper::decodeWall(Blocks::SANDSTONE_WALL(), $in));

src/entity/object/EndCrystal.php

@@ -129,7 +129,7 @@ public function explode() : void{
 		$ev = new EntityPreExplodeEvent($this, 6);
 		$ev->call();
 		if(!$ev->isCancelled()){
-			$explosion = new Explosion($this->getPosition(), $ev->getRadius(), $this);
+			$explosion = new Explosion($this->getPosition(), $ev->getRadius(), $this, $ev->getFireChance());
 			if($ev->isBlockBreaking()){
 				$explosion->explodeA();
 			}

src/entity/object/PrimedTNT.php

@@ -121,7 +121,7 @@ public function explode() : void{
 		$ev->call();
 		if(!$ev->isCancelled()){
 			//TODO: deal with underwater TNT (underwater TNT treats water as if it has a blast resistance of 0)
-			$explosion = new Explosion(Position::fromObject($this->location->add(0, $this->size->getHeight() / 2, 0), $this->getWorld()), $ev->getRadius(), $this);
+			$explosion = new Explosion(Position::fromObject($this->location->add(0, $this->size->getHeight() / 2, 0), $this->getWorld()), $ev->getRadius(), $this, $ev->getFireChance());
 			if($ev->isBlockBreaking()){
 				$explosion->explodeA();
 			}

src/event/block/BlockExplodeEvent.php

@@ -0,0 +1,122 @@
+<?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\event\block;
+
+use pocketmine\block\Block;
+use pocketmine\event\Cancellable;
+use pocketmine\event\CancellableTrait;
+use pocketmine\utils\Utils;
+use pocketmine\world\Position;
+
+/**
+ * Called when a block explodes, after explosion impact has been calculated.
+ *
+ * @see BlockPreExplodeEvent
+ */
+class BlockExplodeEvent extends BlockEvent implements Cancellable{
+	use CancellableTrait;
+
+	/**
+	 * @param Block[] $blocks
+	 * @param Block[] $ignitions
+	 */
+	public function __construct(
+		Block $block,
+		private Position $position,
+		private array $blocks,
+		private float $yield,
+		private array $ignitions
+	){
+		parent::__construct($block);
+
+		Utils::checkFloatNotInfOrNaN("yield", $yield);
+		if($yield < 0.0 || $yield > 100.0){
+			throw new \InvalidArgumentException("Yield must be in range 0.0 - 100.0");
+		}
+	}
+
+	public function getPosition() : Position{
+		return $this->position;
+	}
+
+	/**
+	 * Returns the percentage chance of drops from each block destroyed by the explosion.
+	 *
+	 * @return float 0-100
+	 */
+	public function getYield() : float{
+		return $this->yield;
+	}
+
+	/**
+	 * Sets the percentage chance of drops from each block destroyed by the explosion.
+	 *
+	 * @param float $yield 0-100
+	 */
+	public function setYield(float $yield) : void{
+		Utils::checkFloatNotInfOrNaN("yield", $yield);
+		if($yield < 0.0 || $yield > 100.0){
+			throw new \InvalidArgumentException("Yield must be in range 0.0 - 100.0");
+		}
+		$this->yield = $yield;
+	}
+
+	/**
+	 * Returns a list of blocks destroyed by the explosion.
+	 *
+	 * @return Block[]
+	 */
+	public function getAffectedBlocks() : array{
+		return $this->blocks;
+	}
+
+	/**
+	 * Sets the blocks destroyed by the explosion.
+	 *
+	 * @param Block[] $blocks
+	 */
+	public function setAffectedBlocks(array $blocks) : void{
+		Utils::validateArrayValueType($blocks, fn(Block $block) => null);
+		$this->blocks = $blocks;
+	}
+
+	/**
+	 * Returns a list of affected blocks that will be replaced by fire.
+	 *
+	 * @return Block[]
+	 */
+	public function getIgnitions() : array{
+		return $this->ignitions;
+	}
+
+	/**
+	 * Set the list of blocks that will be replaced by fire.
+	 *
+	 * @param Block[] $ignitions
+	 */
+	public function setIgnitions(array $ignitions) : void{
+		Utils::validateArrayValueType($ignitions, fn(Block $block) => null);
+		$this->ignitions = $ignitions;
+	}
+}