AcaciaTree.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\world\generator\object;
 
use pocketmine\block\VanillaBlocks;
use pocketmine\math\Facing;
use pocketmine\math\Vector3;
use pocketmine\utils\Random;
use pocketmine\world\BlockTransaction;
use function abs;
use function array_rand;
 
final class AcaciaTree extends Tree{
    private const MIN_HEIGHT = 5;
 
    private ?Vector3 $mainBranchTip = null;
    private ?Vector3 $secondBranchTip = null;
 
    public function __construct(){
        parent::__construct(
            VanillaBlocks::ACACIA_LOG(),
            VanillaBlocks::ACACIA_LEAVES(),
            0 //we don't use this anyway - everything is overridden
        );
    }
 
    protected function generateTrunkHeight(Random $random) : int{
        //50% chance of 2 extra blocks, 33% chance 1 or 3, 17% chance 0 or 4
        return self::MIN_HEIGHT + $random->nextRange(0, 2) + $random->nextRange(0, 2);
    }
 
    protected function placeTrunk(int $x, int $y, int $z, Random $random, int $trunkHeight, BlockTransaction $transaction) : void{
        // The base dirt block
        $transaction->addBlockAt($x, $y - 1, $z, VanillaBlocks::DIRT());
 
        $firstBranchHeight = $trunkHeight - 1 - $random->nextRange(0, 3);
 
        for($yy = 0; $yy <= $firstBranchHeight; ++$yy){
            $transaction->addBlockAt($x, $y + $yy, $z, $this->trunkBlock);
        }
 
        $mainBranchFacing = Facing::HORIZONTAL[array_rand(Facing::HORIZONTAL)];
 
        //this branch may grow a second trunk if the diagonal length is less than the max length
        $this->mainBranchTip = $this->placeBranch(
            $transaction,
            new Vector3($x, $y + $firstBranchHeight, $z),
            $mainBranchFacing,
            $random->nextRange(1, 3),
            $trunkHeight - $firstBranchHeight
        );
 
        $secondBranchFacing = Facing::HORIZONTAL[array_rand(Facing::HORIZONTAL)];
        if($secondBranchFacing !== $mainBranchFacing){
            $secondBranchLength = $random->nextRange(1, 3);
            $this->secondBranchTip = $this->placeBranch(
                $transaction,
                new Vector3($x, $y + ($firstBranchHeight - $random->nextRange(0, 1)), $z),
                $secondBranchFacing,
                $secondBranchLength,
                $secondBranchLength //the secondary branch may not form a second trunk
            );
        }
    }
 
    protected function placeBranch(BlockTransaction $transaction, Vector3 $start, int $branchFacing, int $maxDiagonal, int $length) : Vector3{
        $diagonalPlaced = 0;
 
        $nextBlockPos = $start;
        for($yy = 0; $yy < $length; $yy++){
            $nextBlockPos = $nextBlockPos->up();
            if($diagonalPlaced < $maxDiagonal){
                $nextBlockPos = $nextBlockPos->getSide($branchFacing);
                $diagonalPlaced++;
            }
            $transaction->addBlock($nextBlockPos, $this->trunkBlock);
        }
 
        return $nextBlockPos;
    }
 
    protected function placeCanopyLayer(BlockTransaction $transaction, Vector3 $center, int $radius, int $maxTaxicabDistance) : void{
        $centerX = $center->getFloorX();
        $centerY = $center->getFloorY();
        $centerZ = $center->getFloorZ();
 
        for($x = $centerX - $radius; $x <= $centerX + $radius; ++$x){
            for($z = $centerZ - $radius; $z <= $centerZ + $radius; ++$z){
                if(
                    abs($x - $centerX) + abs($z - $centerZ) <= $maxTaxicabDistance &&
                    $transaction->fetchBlockAt($x, $centerY, $z)->canBeReplaced()
                ){
                    $transaction->addBlockAt($x, $centerY, $z, $this->leafBlock);
                }
            }
        }
    }
 
    protected function placeCanopy(int $x, int $y, int $z, Random $random, BlockTransaction $transaction) : void{
        $mainBranchTip = $this->mainBranchTip;
        if($mainBranchTip !== null){
            $this->placeCanopyLayer($transaction, $mainBranchTip, radius: 3, maxTaxicabDistance: 5);
            $this->placeCanopyLayer($transaction, $mainBranchTip->up(), radius: 2, maxTaxicabDistance: 2);
        }
        $secondBranchTip = $this->secondBranchTip;
        if($secondBranchTip !== null){
            $this->placeCanopyLayer($transaction, $secondBranchTip, radius: 2, maxTaxicabDistance: 3);
            $this->placeCanopyLayer($transaction, $secondBranchTip->up(), radius: 1, maxTaxicabDistance: 2);
        }
    }
}