BlockSerializerDeserializerRegistrar.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\data\bedrock\block\convert;
 
use pocketmine\block\Block;
use pocketmine\block\Slab;
use pocketmine\block\Stair;
use pocketmine\block\utils\Colored;
use pocketmine\data\bedrock\block\BlockStateData;
use pocketmine\data\bedrock\block\convert\BlockStateReader as Reader;
use pocketmine\data\bedrock\block\convert\BlockStateWriter as Writer;
use pocketmine\data\bedrock\block\convert\property\CommonProperties;
use pocketmine\data\bedrock\block\convert\property\StringProperty;
use function array_map;
use function count;
use function implode;
use function is_string;
 
final class BlockSerializerDeserializerRegistrar{
 
    public function __construct(
        public readonly BlockStateToObjectDeserializer $deserializer,
        public readonly BlockObjectToStateSerializer $serializer
    ){}
 
    private static function compileFlattenedIdPartMatrix(array $components) : array{
        $result = [];
        foreach($components as $component){
            $column = is_string($component) ? [$component] : $component->getPossibleValues();
 
            if(count($result) === 0){
                $result = array_map(fn($value) => [$value], $column);
            }else{
                $stepResult = [];
                foreach($result as $parts){
                    foreach($column as $value){
                        $stepPart = $parts;
                        $stepPart[] = $value;
                        $stepResult[] = $stepPart;
                    }
                }
 
                $result = $stepResult;
            }
        }
 
        return $result;
    }
 
    private static function serializeFlattenedId(Block $block, array $idComponents) : string{
        $id = "";
        foreach($idComponents as $infix){
            $id .= is_string($infix) ? $infix : $infix->serializePlain($block);
        }
        return $id;
    }
 
    private static function deserializeFlattenedId(Block $baseBlock, array $idComponents, array $idPropertyValues) : Block{
        $preparedBlock = clone $baseBlock;
        foreach($idComponents as $k => $component){
            if($component instanceof StringProperty){
                $fakeValue = $idPropertyValues[$k];
                $component->deserializePlain($preparedBlock, $fakeValue);
            }
        }
 
        return $preparedBlock;
    }
 
    public function mapSimple(Block $block, string $id) : void{
        $this->deserializer->mapSimple($id, fn() => clone $block);
        $this->serializer->mapSimple($block, $id);
    }
 
    public function mapFlattenedId(FlattenedIdModel $model) : void{
        $block = $model->getBlock();
 
        $idComponents = $model->getIdComponents();
        if(count($idComponents) === 0){
            throw new \InvalidArgumentException("No ID components provided");
        }
        $properties = $model->getProperties();
 
        //This is a really cursed hack that lets us essentially write flattened properties as blockstate properties, and
        //then pull them out to compile an ID :D
        //This works surprisingly well and is much more elegant than I would've expected
 
        if(count($properties) > 0){
            $this->serializer->map($block, function(Block $block) use ($idComponents, $properties) : Writer{
                $id = self::serializeFlattenedId($block, $idComponents);
 
                $writer = new Writer($id);
                foreach($properties as $property){
                    $property->serialize($block, $writer);
                }
 
                return $writer;
            });
        }else{
            $this->serializer->map($block, function(Block $block) use ($idComponents) : BlockStateData{
                //fast path for blocks with no state properties
                $id = self::serializeFlattenedId($block, $idComponents);
                return BlockStateData::current($id, []);
            });
        }
 
        $idPermutations = self::compileFlattenedIdPartMatrix($idComponents);
        foreach($idPermutations as $idParts){
            //deconstruct the ID into a partial state
            //we can do this at registration time since there will be multiple deserializers
            $preparedBlock = self::deserializeFlattenedId($block, $idComponents, $idParts);
            $id = implode("", $idParts);
 
            if(count($properties) > 0){
                $this->deserializer->map($id, function(Reader $reader) use ($preparedBlock, $properties) : Block{
                    $block = clone $preparedBlock;
 
                    foreach($properties as $property){
                        $property->deserialize($block, $reader);
                    }
                    return $block;
                });
            }else{
                //fast path for blocks with no state properties
                $this->deserializer->map($id, fn() => clone $preparedBlock);
            }
        }
    }
 
    public function mapColored(Block $block, string $idPrefix, string $idSuffix) : void{
        $this->mapFlattenedId(FlattenedIdModel::create($block)
            ->idComponents([
                $idPrefix,
                CommonProperties::getInstance()->dyeColorIdInfix,
                $idSuffix
            ])
        );
    }
 
    public function mapSlab(Slab $block, string $type) : void{
        $commonProperties = CommonProperties::getInstance();
        $this->mapFlattenedId(FlattenedIdModel::create($block)
            ->idComponents(["minecraft:", $type, "_", $commonProperties->slabIdInfix, "slab"])
            ->properties([$commonProperties->slabPositionProperty])
        );
    }
 
    public function mapStairs(Stair $block, string $id) : void{
        $this->mapModel(Model::create($block, $id)->properties(CommonProperties::getInstance()->stairProperties));
    }
 
    public function mapModel(Model $model) : void{
        $id = $model->getId();
        $block = $model->getBlock();
        $propertyDescriptors = $model->getProperties();
 
        $this->deserializer->map($id, static function(Reader $in) use ($block, $propertyDescriptors) : Block{
            $newBlock = clone $block;
            foreach($propertyDescriptors as $descriptor){
                $descriptor->deserialize($newBlock, $in);
            }
            return $newBlock;
        });
        $this->serializer->map($block, static function(Block $block) use ($id, $propertyDescriptors) : Writer{
            $writer = new Writer($id);
            foreach($propertyDescriptors as $descriptor){
                $descriptor->serialize($block, $writer);
            }
            return $writer;
        });
    }
}