BaseRail.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 pocketmine\block\utils\RailConnectionInfo;
use pocketmine\item\Item;
use pocketmine\math\Facing;
use pocketmine\math\Vector3;
use pocketmine\player\Player;
use pocketmine\world\BlockTransaction;
use function array_reverse;
use function array_search;
use function array_shift;
use function count;
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{
        if($blockReplace->getAdjacentSupportType(Facing::DOWN)->hasEdgeSupport()){
            return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
        }
 
        return false;
    }
 
    public function onPostPlace() : void{
        $this->tryReconnect();
    }
 
    protected static function searchState(array $connections, array $lookup) : ?int{
        $shape = array_search($connections, $lookup, true);
        if($shape === false){
            $shape = array_search(array_reverse($connections), $lookup, true);
        }
        return $shape === false ? null : $shape;
    }
 
    abstract protected function setShapeFromConnections(array $connections) : void;
 
    abstract protected function getCurrentShapeConnections() : array;
 
    private function getConnectedDirections() : array{
        $connections = [];
 
        foreach($this->getCurrentShapeConnections() as $connection){
            $connectionFace = Facing::from($connection & ~RailConnectionInfo::FLAG_ASCEND);
            $other = $this->getSide($connectionFace);
            $otherConnection = Facing::opposite($connectionFace)->value;
 
            if(($connection & RailConnectionInfo::FLAG_ASCEND) !== 0){
                $other = $other->getSide(Facing::UP);
 
            }elseif(!($other instanceof BaseRail)){ //check for rail sloping up to meet this one
                $other = $other->getSide(Facing::DOWN);
                $otherConnection |= RailConnectionInfo::FLAG_ASCEND;
            }
 
            if(
                $other instanceof BaseRail &&
                in_array($otherConnection, $other->getCurrentShapeConnections(), true)
            ){
                $connections[] = $connection;
            }
        }
 
        return $connections;
    }
 
    private function getPossibleConnectionDirections(array $constraints) : array{
        switch(count($constraints)){
            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
                ];
                foreach($possible as $p => $_){
                    $possible[$p | RailConnectionInfo::FLAG_ASCEND] = true;
                }
 
                return $possible;
            case 1:
                return $this->getPossibleConnectionDirectionsOneConstraint(array_shift($constraints));
            case 2:
                return [];
            default:
                throw new \InvalidArgumentException("Expected at most 2 constraints, got " . count($constraints));
        }
    }
 
    protected function getPossibleConnectionDirectionsOneConstraint(int $constraint) : array{
        $opposite = Facing::opposite(Facing::from($constraint & ~RailConnectionInfo::FLAG_ASCEND));
 
        $possible = [$opposite->value => 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;
        }
 
        return $possible;
    }
 
    private function tryReconnect() : void{
        $thisConnections = $this->getConnectedDirections();
        $changed = false;
 
        $world = $this->position->getWorld();
        do{
            $possible = $this->getPossibleConnectionDirections($thisConnections);
            $continue = false;
 
            foreach($possible as $thisSide => $_){
                $thisSideEnum = Facing::from($thisSide & ~RailConnectionInfo::FLAG_ASCEND);
                $otherSide = Facing::opposite($thisSideEnum)->value;
 
                $other = $this->getSide($thisSideEnum);
 
                if(($thisSide & RailConnectionInfo::FLAG_ASCEND) !== 0){
                    $other = $other->getSide(Facing::UP);
 
                }elseif(!($other instanceof BaseRail)){ //check if other rails can slope up to meet this one
                    $other = $other->getSide(Facing::DOWN);
                    $otherSide |= RailConnectionInfo::FLAG_ASCEND;
                }
 
                if(!($other instanceof BaseRail) || count($otherConnections = $other->getConnectedDirections()) >= 2){
                    //we can only connect to a rail that has less than 2 connections
                    continue;
                }
 
                $otherPossible = $other->getPossibleConnectionDirections($otherConnections);
 
                if(isset($otherPossible[$otherSide])){
                    $otherConnections[] = $otherSide;
                    $other->setConnections($otherConnections);
                    $world->setBlock($other->position, $other);
 
                    $changed = true;
                    $thisConnections[] = $thisSide;
                    $continue = count($thisConnections) < 2;
 
                    break; //force recomputing possible directions, since this connection could invalidate others
                }
            }
        }while($continue);
 
        if($changed){
            $this->setConnections($thisConnections);
            $world->setBlock($this->position, $this);
        }
    }
 
    private function setConnections(array $connections) : void{
        if(count($connections) === 1){
            $connections[] = Facing::opposite(Facing::from($connections[0] & ~RailConnectionInfo::FLAG_ASCEND))->value;
        }elseif(count($connections) !== 2){
            throw new \InvalidArgumentException("Expected exactly 2 connections, got " . count($connections));
        }
 
        $this->setShapeFromConnections($connections);
    }
 
    public function onNearbyBlockChange() : void{
        $world = $this->position->getWorld();
        if(!$this->getAdjacentSupportType(Facing::DOWN)->hasEdgeSupport()){
            $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()){
                    $world->useBreakOn($this->position);
                    break;
                }
            }
        }
    }
}