Block.php

<?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 pmmp\encoding\BE;
use pmmp\encoding\LE;
use pocketmine\block\tile\Spawnable;
use pocketmine\block\tile\Tile;
use pocketmine\block\utils\SupportType;
use pocketmine\data\runtime\InvalidSerializedRuntimeDataException;
use pocketmine\data\runtime\RuntimeDataDescriber;
use pocketmine\data\runtime\RuntimeDataReader;
use pocketmine\data\runtime\RuntimeDataSizeCalculator;
use pocketmine\data\runtime\RuntimeDataWriter;
use pocketmine\entity\Entity;
use pocketmine\entity\projectile\Projectile;
use pocketmine\item\enchantment\AvailableEnchantmentRegistry;
use pocketmine\item\enchantment\ItemEnchantmentTagRegistry;
use pocketmine\item\enchantment\ItemEnchantmentTags;
use pocketmine\item\enchantment\VanillaEnchantments;
use pocketmine\item\Item;
use pocketmine\item\ItemBlock;
use pocketmine\math\AxisAlignedBB;
use pocketmine\math\Facing;
use pocketmine\math\RayTraceResult;
use pocketmine\math\Vector3;
use pocketmine\nbt\tag\CompoundTag;
use pocketmine\player\Player;
use pocketmine\utils\AssumptionFailedError;
use pocketmine\world\BlockTransaction;
use pocketmine\world\format\Chunk;
use pocketmine\world\Position;
use pocketmine\world\World;
use function count;
use function get_class;
use function hash;
use const PHP_INT_MAX;
 
class Block{
    public const INTERNAL_STATE_DATA_BITS = 11;
    public const INTERNAL_STATE_DATA_MASK = ~(~0 << self::INTERNAL_STATE_DATA_BITS);
 
    public const EMPTY_STATE_ID = (BlockTypeIds::AIR << self::INTERNAL_STATE_DATA_BITS) | (-7482769108513497636 & self::INTERNAL_STATE_DATA_MASK);
 
    protected BlockIdentifier $idInfo;
    protected string $fallbackName;
    protected BlockTypeInfo $typeInfo;
    protected Position $position;
 
    protected ?array $collisionBoxes = null;
 
    private int $requiredBlockItemStateDataBits;
    private int $requiredBlockOnlyStateDataBits;
 
    private Block $defaultState;
 
    private int $stateIdXorMask;
 
    private static function computeStateIdXorMask(int $typeId) : int{
        //TODO: the mixed byte order here is probably a mistake, but it doesn't break anything for now
        return
            $typeId << self::INTERNAL_STATE_DATA_BITS |
            (BE::unpackSignedLong(hash('xxh3', LE::packSignedLong($typeId), binary: true)) & self::INTERNAL_STATE_DATA_MASK);
    }
 
    public function __construct(BlockIdentifier $idInfo, string $name, BlockTypeInfo $typeInfo){
        $this->idInfo = $idInfo;
        $this->fallbackName = $name;
        $this->typeInfo = $typeInfo;
        $this->position = new Position(0, 0, 0, null);
 
        $calculator = new RuntimeDataSizeCalculator();
        $this->describeBlockItemState($calculator);
        $this->requiredBlockItemStateDataBits = $calculator->getBitsUsed();
 
        $calculator = new RuntimeDataSizeCalculator();
        $this->describeBlockOnlyState($calculator);
        $this->requiredBlockOnlyStateDataBits = $calculator->getBitsUsed();
 
        $this->stateIdXorMask = self::computeStateIdXorMask($idInfo->getBlockTypeId());
 
        //this must be done last, otherwise the defaultState could have uninitialized fields
        $defaultState = clone $this;
        $this->defaultState = $defaultState;
        $defaultState->defaultState = $defaultState;
    }
 
    public function __clone(){
        $this->position = clone $this->position;
    }
 
    public function getIdInfo() : BlockIdentifier{
        return $this->idInfo;
    }
 
    public function getName() : string{
        return $this->fallbackName;
    }
 
    public function getTypeId() : int{
        return $this->idInfo->getBlockTypeId();
    }
 
    public function getStateId() : int{
        return $this->encodeFullState() ^ $this->stateIdXorMask;
    }
 
    public function hasSameTypeId(Block $other) : bool{
        return $this->getTypeId() === $other->getTypeId();
    }
 
    public function isSameState(Block $other) : bool{
        return $this->getStateId() === $other->getStateId();
    }
 
    public function getTypeTags() : array{
        return $this->typeInfo->getTypeTags();
    }
 
    public function hasTypeTag(string $tag) : bool{
        return $this->typeInfo->hasTypeTag($tag);
    }
 
    public function asItem() : Item{
        $normalized = clone $this->defaultState;
        $normalized->decodeBlockItemState($this->encodeBlockItemState());
        return new ItemBlock($normalized);
    }
 
    private function decodeBlockItemState(int $data) : void{
        $reader = new RuntimeDataReader($this->requiredBlockItemStateDataBits, $data);
 
        $this->describeBlockItemState($reader);
        $readBits = $reader->getOffset();
        if($this->requiredBlockItemStateDataBits !== $readBits){
            throw new \LogicException(get_class($this) . ": Exactly $this->requiredBlockItemStateDataBits bits of block-item state data were provided, but $readBits were read");
        }
    }
 
    private function decodeBlockOnlyState(int $data) : void{
        $reader = new RuntimeDataReader($this->requiredBlockOnlyStateDataBits, $data);
 
        $this->describeBlockOnlyState($reader);
        $readBits = $reader->getOffset();
        if($this->requiredBlockOnlyStateDataBits !== $readBits){
            throw new \LogicException(get_class($this) . ": Exactly $this->requiredBlockOnlyStateDataBits bits of block-only state data were provided, but $readBits were read");
        }
    }
 
    private function encodeBlockItemState() : int{
        $writer = new RuntimeDataWriter($this->requiredBlockItemStateDataBits);
 
        $this->describeBlockItemState($writer);
        $writtenBits = $writer->getOffset();
        if($this->requiredBlockItemStateDataBits !== $writtenBits){
            throw new \LogicException(get_class($this) . ": Exactly $this->requiredBlockItemStateDataBits bits of block-item state data were expected, but $writtenBits were written");
        }
 
        return $writer->getValue();
    }
 
    private function encodeBlockOnlyState() : int{
        $writer = new RuntimeDataWriter($this->requiredBlockOnlyStateDataBits);
 
        $this->describeBlockOnlyState($writer);
        $writtenBits = $writer->getOffset();
        if($this->requiredBlockOnlyStateDataBits !== $writtenBits){
            throw new \LogicException(get_class($this) . ": Exactly $this->requiredBlockOnlyStateDataBits bits of block-only state data were expected, but $writtenBits were written");
        }
 
        return $writer->getValue();
    }
 
    private function encodeFullState() : int{
        $blockItemBits = $this->requiredBlockItemStateDataBits;
        $blockOnlyBits = $this->requiredBlockOnlyStateDataBits;
 
        if($blockOnlyBits === 0 && $blockItemBits === 0){
            return 0;
        }
 
        $result = 0;
        if($blockItemBits > 0){
            $result |= $this->encodeBlockItemState();
        }
        if($blockOnlyBits > 0){
            $result |= $this->encodeBlockOnlyState() << $blockItemBits;
        }
 
        return $result;
    }
 
    public function describeBlockItemState(RuntimeDataDescriber $w) : void{
        //NOOP
    }
 
    protected function describeBlockOnlyState(RuntimeDataDescriber $w) : void{
        //NOOP
    }
 
    public function generateStatePermutations() : \Generator{
        //TODO: this bruteforce approach to discovering all valid states is very inefficient for larger state data sizes
        //at some point we'll need to find a better way to do this
        $bits = $this->requiredBlockItemStateDataBits + $this->requiredBlockOnlyStateDataBits;
        if($bits > Block::INTERNAL_STATE_DATA_BITS){
            throw new \LogicException("Block state data cannot use more than " . Block::INTERNAL_STATE_DATA_BITS . " bits");
        }
        for($blockItemStateData = 0; $blockItemStateData < (1 << $this->requiredBlockItemStateDataBits); ++$blockItemStateData){
            $withType = clone $this;
            try{
                $withType->decodeBlockItemState($blockItemStateData);
                $encoded = $withType->encodeBlockItemState();
                if($encoded !== $blockItemStateData){
                    throw new \LogicException(static::class . "::decodeBlockItemState() accepts invalid inputs (returned $encoded for input $blockItemStateData)");
                }
            }catch(InvalidSerializedRuntimeDataException){ //invalid property combination, leave it
                continue;
            }
 
            for($blockOnlyStateData = 0; $blockOnlyStateData < (1 << $this->requiredBlockOnlyStateDataBits); ++$blockOnlyStateData){
                $withState = clone $withType;
                try{
                    $withState->decodeBlockOnlyState($blockOnlyStateData);
                    $encoded = $withState->encodeBlockOnlyState();
                    if($encoded !== $blockOnlyStateData){
                        throw new \LogicException(static::class . "::decodeBlockOnlyState() accepts invalid inputs (returned $encoded for input $blockOnlyStateData)");
                    }
                }catch(InvalidSerializedRuntimeDataException){ //invalid property combination, leave it
                    continue;
                }
 
                yield $withState;
            }
        }
    }
 
    public function readStateFromWorld() : Block{
        return $this;
    }
 
    public function writeStateToWorld() : void{
        $world = $this->position->getWorld();
        $chunk = $world->getOrLoadChunkAtPosition($this->position);
        if($chunk === null){
            throw new AssumptionFailedError("World::setBlock() should have loaded the chunk before calling this method");
        }
        $chunk->setBlockStateId($this->position->x & Chunk::COORD_MASK, $this->position->y, $this->position->z & Chunk::COORD_MASK, $this->getStateId());
 
        $tileType = $this->idInfo->getTileClass();
        $oldTile = $world->getTile($this->position);
        if($oldTile !== null){
            if($tileType === null || !($oldTile instanceof $tileType)){
                $oldTile->close();
                $oldTile = null;
            }elseif($oldTile instanceof Spawnable){
                $oldTile->clearSpawnCompoundCache(); //destroy old network cache
            }
        }
        if($oldTile === null && $tileType !== null){
            $tile = new $tileType($world, $this->position->asVector3());
            $world->addTile($tile);
        }
    }
 
    public function canBePlaced() : bool{
        return true;
    }
 
    public function canBeReplaced() : bool{
        return false;
    }
 
    public function canBePlacedAt(Block $blockReplace, Vector3 $clickVector, Facing $face, bool $isClickedBlock) : bool{
        return $blockReplace->canBeReplaced();
    }
 
    public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, Facing $face, Vector3 $clickVector, ?Player $player = null) : bool{
        $tx->addBlock($blockReplace->position, $this);
        return true;
    }
 
    public function onPostPlace() : void{
 
    }
 
    public function getBreakInfo() : BlockBreakInfo{
        return $this->typeInfo->getBreakInfo();
    }
 
    public function getEnchantmentTags() : array{
        return $this->typeInfo->getEnchantmentTags();
    }
 
    public function onBreak(Item $item, ?Player $player = null, array &$returnedItems = []) : bool{
        $world = $this->position->getWorld();
        if(($t = $world->getTile($this->position)) !== null){
            $t->onBlockDestroyed();
        }
        $world->setBlock($this->position, VanillaBlocks::AIR());
        return true;
    }
 
    public function onNearbyBlockChange() : void{
 
    }
 
    public function ticksRandomly() : bool{
        return false;
    }
 
    public function onRandomTick() : void{
 
    }
 
    public function onScheduledUpdate() : void{
 
    }
 
    public function onInteract(Item $item, Facing $face, Vector3 $clickVector, ?Player $player = null, array &$returnedItems = []) : bool{
        return false;
    }
 
    public function onAttack(Item $item, Facing $face, ?Player $player = null) : bool{
        return false;
    }
 
    public function getFrictionFactor() : float{
        return 0.6;
    }
 
    public function getLightLevel() : int{
        return 0;
    }
 
    public function getLightFilter() : int{
        return $this->isTransparent() ? 0 : 15;
    }
 
    public function blocksDirectSkyLight() : bool{
        return $this->getLightFilter() > 0;
    }
 
    public function isTransparent() : bool{
        return false;
    }
 
    public function isSolid() : bool{
        return true;
    }
 
    public function canBeFlowedInto() : bool{
        return false;
    }
 
    public function canClimb() : bool{
        return false;
    }
 
    final public function getPosition() : Position{
        return $this->position;
    }
 
    final public function position(World $world, int $x, int $y, int $z) : void{
        $this->position = new Position($x, $y, $z, $world);
        $this->collisionBoxes = null;
    }
 
    public function getDrops(Item $item) : array{
        if($this->getBreakInfo()->isToolCompatible($item)){
            if($this->isAffectedBySilkTouch() && $item->hasEnchantment(VanillaEnchantments::SILK_TOUCH())){
                return $this->getSilkTouchDrops($item);
            }
 
            return $this->getDropsForCompatibleTool($item);
        }
 
        return $this->getDropsForIncompatibleTool($item);
    }
 
    public function getDropsForCompatibleTool(Item $item) : array{
        return [$this->asItem()];
    }
 
    public function getDropsForIncompatibleTool(Item $item) : array{
        return [];
    }
 
    public function getSilkTouchDrops(Item $item) : array{
        return [$this->asItem()];
    }
 
    public function getXpDropForTool(Item $item) : int{
        if($item->hasEnchantment(VanillaEnchantments::SILK_TOUCH()) || !$this->getBreakInfo()->isToolCompatible($item)){
            return 0;
        }
 
        return $this->getXpDropAmount();
    }
 
    protected function getXpDropAmount() : int{
        return 0;
    }
 
    public function isAffectedBySilkTouch() : bool{
        return false;
    }
 
    public function getPickedItem(bool $addUserData = false) : Item{
        $item = $this->asItem();
        if($addUserData){
            $tile = $this->position->getWorld()->getTile($this->position);
            if($tile instanceof Tile){
                $nbt = $tile->getCleanedNBT();
                if($nbt instanceof CompoundTag){
                    $item->setCustomBlockData($nbt);
                    $item->setLore(["+(DATA)"]);
                }
            }
        }
        return $item;
    }
 
    public function getFuelTime() : int{
        return 0;
    }
 
    public function getMaxStackSize() : int{
        return 64;
    }
 
    public function isFireProofAsItem() : bool{
        return false;
    }
 
    public function getFlameEncouragement() : int{
        return 0;
    }
 
    public function getFlammability() : int{
        return 0;
    }
 
    public function burnsForever() : bool{
        return false;
    }
 
    public function isFlammable() : bool{
        return $this->getFlammability() > 0;
    }
 
    public function onIncinerate() : void{
 
    }
 
    public function getSide(Facing $side, int $step = 1){
        $position = $this->position;
        if($position->isValid()){
            [$dx, $dy, $dz] = Facing::OFFSET[$side->value] ?? [0, 0, 0];
            return $position->getWorld()->getBlockAt(
                $position->x + ($dx * $step),
                $position->y + ($dy * $step),
                $position->z + ($dz * $step)
            );
        }
 
        throw new \LogicException("Block does not have a valid world");
    }
 
    public function getHorizontalSides() : \Generator{
        $world = $this->position->getWorld();
        foreach(Facing::HORIZONTAL as $facing){
            [$dx, $dy, $dz] = Facing::OFFSET[$facing->value];
            //TODO: yield Facing as the key?
            yield $world->getBlockAt(
                $this->position->x + $dx,
                $this->position->y + $dy,
                $this->position->z + $dz
            );
        }
    }
 
    public function getAllSides() : \Generator{
        $world = $this->position->getWorld();
        foreach(Facing::OFFSET as [$dx, $dy, $dz]){
            //TODO: yield Facing as the key?
            yield $world->getBlockAt(
                $this->position->x + $dx,
                $this->position->y + $dy,
                $this->position->z + $dz
            );
        }
    }
 
    public function getAffectedBlocks() : array{
        return [$this];
    }
 
    public function __toString(){
        return "Block[" . $this->getName() . "] (" . $this->getTypeId() . ":" . $this->encodeFullState() . ")";
    }
 
    public function collidesWithBB(AxisAlignedBB $bb) : bool{
        foreach($this->getCollisionBoxes() as $bb2){
            if($bb->intersectsWith($bb2)){
                return true;
            }
        }
 
        return false;
    }
 
    public function hasEntityCollision() : bool{
        return false;
    }
 
    public function onEntityInside(Entity $entity) : bool{
        return true;
    }
 
    public function addVelocityToEntity(Entity $entity) : ?Vector3{
        return null;
    }
 
    public function onEntityLand(Entity $entity) : ?float{
        return null;
    }
 
    public function onProjectileHit(Projectile $projectile, RayTraceResult $hitResult) : void{
        //NOOP
    }
 
    final public function getCollisionBoxes() : array{
        if($this->collisionBoxes === null){
            $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);
            }
        }
 
        return $this->collisionBoxes;
    }
 
    public function getModelPositionOffset() : ?Vector3{
        return null;
    }
 
    protected function recalculateCollisionBoxes() : array{
        return [AxisAlignedBB::one()];
    }
 
    public function getSupportType(Facing $facing) : SupportType{
        return SupportType::FULL;
    }
 
    protected function getAdjacentSupportType(Facing $facing) : SupportType{
        return $this->getSide($facing)->getSupportType(Facing::opposite($facing));
    }
 
    public function isFullCube() : bool{
        $bb = $this->getCollisionBoxes();
 
        return count($bb) === 1 && $bb[0]->getAverageEdgeLength() >= 1 && $bb[0]->isCube();
    }
 
    public function calculateIntercept(Vector3 $pos1, Vector3 $pos2) : ?RayTraceResult{
        $bbs = $this->getCollisionBoxes();
        if(count($bbs) === 0){
            return null;
        }
 
        $currentHit = null;
        $currentDistance = PHP_INT_MAX;
 
        foreach($bbs as $bb){
            $nextHit = $bb->calculateIntercept($pos1, $pos2);
            if($nextHit === null){
                continue;
            }
 
            $nextDistance = $nextHit->hitVector->distanceSquared($pos1);
            if($nextDistance < $currentDistance){
                $currentHit = $nextHit;
                $currentDistance = $nextDistance;
            }
        }
 
        return $currentHit;
    }
}