BlockTransaction.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;
 
use pocketmine\block\Block;
use pocketmine\math\Vector3;
use pocketmine\utils\Utils;
 
class BlockTransaction{
    private array $blocks = [];
 
    private array $validators = [];
 
    public function __construct(private ChunkManager $world){
        $this->addValidator(static function(ChunkManager $world, int $x, int $y, int $z) : bool{
            return $world->isInWorld($x, $y, $z);
        });
    }
 
    public function addBlock(Vector3 $pos, Block $state) : self{
        return $this->addBlockAt($pos->getFloorX(), $pos->getFloorY(), $pos->getFloorZ(), $state);
    }
 
    public function addBlockAt(int $x, int $y, int $z, Block $state) : self{
        $this->blocks[$x][$y][$z] = $state;
        return $this;
    }
 
    public function fetchBlock(Vector3 $pos) : Block{
        return $this->fetchBlockAt($pos->getFloorX(), $pos->getFloorY(), $pos->getFloorZ());
    }
 
    public function fetchBlockAt(int $x, int $y, int $z) : Block{
        return $this->blocks[$x][$y][$z] ?? $this->world->getBlockAt($x, $y, $z);
    }
 
    public function apply() : bool{
        foreach($this->getBlocks() as [$x, $y, $z, $_]){
            foreach($this->validators as $validator){
                if(!$validator($this->world, $x, $y, $z)){
                    return false;
                }
            }
        }
        $changedBlocks = 0;
        foreach($this->getBlocks() as [$x, $y, $z, $block]){
            $oldBlock = $this->world->getBlockAt($x, $y, $z);
            if(!$oldBlock->isSameState($block)){
                $this->world->setBlockAt($x, $y, $z, $block);
                $changedBlocks++;
            }
        }
        return $changedBlocks !== 0;
    }
 
    public function getBlocks() : \Generator{
        foreach($this->blocks as $x => $yLine){
            foreach($yLine as $y => $zLine){
                foreach($zLine as $z => $block){
                    yield [$x, $y, $z, $block];
                }
            }
        }
    }
 
    public function addValidator(\Closure $validator) : void{
        Utils::validateCallableSignature($this->dummyValidator(...), $validator);
        $this->validators[] = $validator;
    }
 
    public function dummyValidator(ChunkManager $world, int $x, int $y, int $z) : bool{
        return true;
    }
}