CommonTypes.php

<?php
 
/*
 * This file is part of BedrockProtocol.
 * Copyright (C) 2014-2022 PocketMine Team <https://github.com/pmmp/BedrockProtocol>
 *
 * BedrockProtocol 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.
 */
 
declare(strict_types=1);
 
namespace pocketmine\network\mcpe\protocol\serializer;
 
use pmmp\encoding\Byte;
use pmmp\encoding\ByteBufferReader;
use pmmp\encoding\ByteBufferWriter;
use pmmp\encoding\DataDecodeException;
use pmmp\encoding\LE;
use pmmp\encoding\VarInt;
use pocketmine\math\Vector2;
use pocketmine\math\Vector3;
use pocketmine\nbt\NbtDataException;
use pocketmine\nbt\tag\CompoundTag;
use pocketmine\nbt\TreeRoot;
use pocketmine\network\mcpe\protocol\PacketDecodeException;
use pocketmine\network\mcpe\protocol\types\BlockPosition;
use pocketmine\network\mcpe\protocol\types\BoolGameRule;
use pocketmine\network\mcpe\protocol\types\command\CommandOriginData;
use pocketmine\network\mcpe\protocol\types\entity\BlockPosMetadataProperty;
use pocketmine\network\mcpe\protocol\types\entity\ByteMetadataProperty;
use pocketmine\network\mcpe\protocol\types\entity\CompoundTagMetadataProperty;
use pocketmine\network\mcpe\protocol\types\entity\EntityLink;
use pocketmine\network\mcpe\protocol\types\entity\FloatMetadataProperty;
use pocketmine\network\mcpe\protocol\types\entity\IntMetadataProperty;
use pocketmine\network\mcpe\protocol\types\entity\LongMetadataProperty;
use pocketmine\network\mcpe\protocol\types\entity\MetadataProperty;
use pocketmine\network\mcpe\protocol\types\entity\ShortMetadataProperty;
use pocketmine\network\mcpe\protocol\types\entity\StringMetadataProperty;
use pocketmine\network\mcpe\protocol\types\entity\Vec3MetadataProperty;
use pocketmine\network\mcpe\protocol\types\FloatGameRule;
use pocketmine\network\mcpe\protocol\types\GameRule;
use pocketmine\network\mcpe\protocol\types\IntGameRule;
use pocketmine\network\mcpe\protocol\types\inventory\ItemStack;
use pocketmine\network\mcpe\protocol\types\inventory\ItemStackWrapper;
use pocketmine\network\mcpe\protocol\types\recipe\ComplexAliasItemDescriptor;
use pocketmine\network\mcpe\protocol\types\recipe\IntIdMetaItemDescriptor;
use pocketmine\network\mcpe\protocol\types\recipe\ItemDescriptorType;
use pocketmine\network\mcpe\protocol\types\recipe\MolangItemDescriptor;
use pocketmine\network\mcpe\protocol\types\recipe\RecipeIngredient;
use pocketmine\network\mcpe\protocol\types\recipe\StringIdMetaItemDescriptor;
use pocketmine\network\mcpe\protocol\types\recipe\TagItemDescriptor;
use pocketmine\network\mcpe\protocol\types\skin\PersonaPieceTintColor;
use pocketmine\network\mcpe\protocol\types\skin\PersonaSkinPiece;
use pocketmine\network\mcpe\protocol\types\skin\SkinAnimation;
use pocketmine\network\mcpe\protocol\types\skin\SkinData;
use pocketmine\network\mcpe\protocol\types\skin\SkinImage;
use pocketmine\network\mcpe\protocol\types\StructureEditorData;
use pocketmine\network\mcpe\protocol\types\StructureSettings;
use Ramsey\Uuid\Uuid;
use Ramsey\Uuid\UuidInterface;
use function count;
use function strlen;
use function strrev;
use function substr;
 
final class CommonTypes{
 
    private function __construct(){
        //NOOP
    }
 
    public static function getString(ByteBufferReader $in) : string{
        return $in->readByteArray(VarInt::readUnsignedInt($in));
    }
 
    public static function putString(ByteBufferWriter $out, string $v) : void{
        VarInt::writeUnsignedInt($out, strlen($v));
        $out->writeByteArray($v);
    }
 
    public static function getBool(ByteBufferReader $in) : bool{
        return Byte::readUnsigned($in) !== 0;
    }
 
    public static function putBool(ByteBufferWriter $out, bool $v) : void{
        Byte::writeUnsigned($out, $v ? 1 : 0);
    }
 
    public static function getUUID(ByteBufferReader $in) : UuidInterface{
        //This is two little-endian longs: bytes 7-0 followed by bytes 15-8
        $p1 = strrev($in->readByteArray(8));
        $p2 = strrev($in->readByteArray(8));
        return Uuid::fromBytes($p1 . $p2);
    }
 
    public static function putUUID(ByteBufferWriter $out, UuidInterface $uuid) : void{
        $bytes = $uuid->getBytes();
        $out->writeByteArray(strrev(substr($bytes, 0, 8)));
        $out->writeByteArray(strrev(substr($bytes, 8, 8)));
    }
 
    public static function getSkin(ByteBufferReader $in) : SkinData{
        $skinId = self::getString($in);
        $skinPlayFabId = self::getString($in);
        $skinResourcePatch = self::getString($in);
        $skinData = self::getSkinImage($in);
        $animationCount = LE::readUnsignedInt($in);
        $animations = [];
        for($i = 0; $i < $animationCount; ++$i){
            $skinImage = self::getSkinImage($in);
            $animationType = LE::readUnsignedInt($in);
            $animationFrames = LE::readFloat($in);
            $expressionType = LE::readUnsignedInt($in);
            $animations[] = new SkinAnimation($skinImage, $animationType, $animationFrames, $expressionType);
        }
        $capeData = self::getSkinImage($in);
        $geometryData = self::getString($in);
        $geometryDataVersion = self::getString($in);
        $animationData = self::getString($in);
        $capeId = self::getString($in);
        $fullSkinId = self::getString($in);
        $armSize = self::getString($in);
        $skinColor = self::getString($in);
        $personaPieceCount = LE::readUnsignedInt($in);
        $personaPieces = [];
        for($i = 0; $i < $personaPieceCount; ++$i){
            $pieceId = self::getString($in);
            $pieceType = self::getString($in);
            $packId = self::getString($in);
            $isDefaultPiece = self::getBool($in);
            $productId = self::getString($in);
            $personaPieces[] = new PersonaSkinPiece($pieceId, $pieceType, $packId, $isDefaultPiece, $productId);
        }
        $pieceTintColorCount = LE::readUnsignedInt($in);
        $pieceTintColors = [];
        for($i = 0; $i < $pieceTintColorCount; ++$i){
            $pieceType = self::getString($in);
            $colorCount = LE::readUnsignedInt($in);
            $colors = [];
            for($j = 0; $j < $colorCount; ++$j){
                $colors[] = self::getString($in);
            }
            $pieceTintColors[] = new PersonaPieceTintColor(
                $pieceType,
                $colors
            );
        }
 
        $premium = self::getBool($in);
        $persona = self::getBool($in);
        $capeOnClassic = self::getBool($in);
        $isPrimaryUser = self::getBool($in);
        $override = self::getBool($in);
 
        return new SkinData(
            $skinId,
            $skinPlayFabId,
            $skinResourcePatch,
            $skinData,
            $animations,
            $capeData,
            $geometryData,
            $geometryDataVersion,
            $animationData,
            $capeId,
            $fullSkinId,
            $armSize,
            $skinColor,
            $personaPieces,
            $pieceTintColors,
            true,
            $premium,
            $persona,
            $capeOnClassic,
            $isPrimaryUser,
            $override,
        );
    }
 
    public static function putSkin(ByteBufferWriter $out, SkinData $skin) : void{
        self::putString($out, $skin->getSkinId());
        self::putString($out, $skin->getPlayFabId());
        self::putString($out, $skin->getResourcePatch());
        self::putSkinImage($out, $skin->getSkinImage());
        LE::writeUnsignedInt($out, count($skin->getAnimations()));
        foreach($skin->getAnimations() as $animation){
            self::putSkinImage($out, $animation->getImage());
            LE::writeUnsignedInt($out, $animation->getType());
            LE::writeFloat($out, $animation->getFrames());
            LE::writeUnsignedInt($out, $animation->getExpressionType());
        }
        self::putSkinImage($out, $skin->getCapeImage());
        self::putString($out, $skin->getGeometryData());
        self::putString($out, $skin->getGeometryDataEngineVersion());
        self::putString($out, $skin->getAnimationData());
        self::putString($out, $skin->getCapeId());
        self::putString($out, $skin->getFullSkinId());
        self::putString($out, $skin->getArmSize());
        self::putString($out, $skin->getSkinColor());
        LE::writeUnsignedInt($out, count($skin->getPersonaPieces()));
        foreach($skin->getPersonaPieces() as $piece){
            self::putString($out, $piece->getPieceId());
            self::putString($out, $piece->getPieceType());
            self::putString($out, $piece->getPackId());
            self::putBool($out, $piece->isDefaultPiece());
            self::putString($out, $piece->getProductId());
        }
        LE::writeUnsignedInt($out, count($skin->getPieceTintColors()));
        foreach($skin->getPieceTintColors() as $tint){
            self::putString($out, $tint->getPieceType());
            LE::writeUnsignedInt($out, count($tint->getColors()));
            foreach($tint->getColors() as $color){
                self::putString($out, $color);
            }
        }
        self::putBool($out, $skin->isPremium());
        self::putBool($out, $skin->isPersona());
        self::putBool($out, $skin->isPersonaCapeOnClassic());
        self::putBool($out, $skin->isPrimaryUser());
        self::putBool($out, $skin->isOverride());
    }
 
    private static function getSkinImage(ByteBufferReader $in) : SkinImage{
        $width = LE::readUnsignedInt($in);
        $height = LE::readUnsignedInt($in);
        $data = self::getString($in);
        try{
            return new SkinImage($height, $width, $data);
        }catch(\InvalidArgumentException $e){
            throw new PacketDecodeException($e->getMessage(), 0, $e);
        }
    }
 
    private static function putSkinImage(ByteBufferWriter $out, SkinImage $image) : void{
        LE::writeUnsignedInt($out, $image->getWidth());
        LE::writeUnsignedInt($out, $image->getHeight());
        self::putString($out, $image->getData());
    }
 
    private static function getItemStackHeader(ByteBufferReader $in) : array{
        $id = VarInt::readSignedInt($in);
        if($id === 0){
            return [0, 0, 0];
        }
 
        $count = LE::readUnsignedShort($in);
        $meta = VarInt::readUnsignedInt($in);
 
        return [$id, $count, $meta];
    }
 
    private static function putItemStackHeader(ByteBufferWriter $out, ItemStack $itemStack) : bool{
        if($itemStack->getId() === 0){
            VarInt::writeSignedInt($out, 0);
            return false;
        }
 
        VarInt::writeSignedInt($out, $itemStack->getId());
        LE::writeUnsignedShort($out, $itemStack->getCount());
        VarInt::writeUnsignedInt($out, $itemStack->getMeta());
 
        return true;
    }
 
    private static function getItemStackFooter(ByteBufferReader $in, int $id, int $meta, int $count) : ItemStack{
        $blockRuntimeId = VarInt::readSignedInt($in);
        $rawExtraData = self::getString($in);
 
        return new ItemStack($id, $meta, $count, $blockRuntimeId, $rawExtraData);
    }
 
    private static function putItemStackFooter(ByteBufferWriter $out, ItemStack $itemStack) : void{
        VarInt::writeSignedInt($out, $itemStack->getBlockRuntimeId());
        self::putString($out, $itemStack->getRawExtraData());
    }
 
    public static function getItemStackWithoutStackId(ByteBufferReader $in) : ItemStack{
        [$id, $count, $meta] = self::getItemStackHeader($in);
 
        return $id !== 0 ? self::getItemStackFooter($in, $id, $meta, $count) : ItemStack::null();
 
    }
 
    public static function putItemStackWithoutStackId(ByteBufferWriter $out, ItemStack $itemStack) : void{
        if(self::putItemStackHeader($out, $itemStack)){
            self::putItemStackFooter($out, $itemStack);
        }
    }
 
    public static function getItemStackWrapper(ByteBufferReader $in) : ItemStackWrapper{
        [$id, $count, $meta] = self::getItemStackHeader($in);
        if($id === 0){
            return new ItemStackWrapper(0, ItemStack::null());
        }
 
        $hasNetId = self::getBool($in);
        $stackId = $hasNetId ? self::readServerItemStackId($in) : 0;
 
        $itemStack = self::getItemStackFooter($in, $id, $meta, $count);
 
        return new ItemStackWrapper($stackId, $itemStack);
    }
 
    public static function putItemStackWrapper(ByteBufferWriter $out, ItemStackWrapper $itemStackWrapper) : void{
        $itemStack = $itemStackWrapper->getItemStack();
        if(self::putItemStackHeader($out, $itemStack)){
            $hasNetId = $itemStackWrapper->getStackId() !== 0;
            self::putBool($out, $hasNetId);
            if($hasNetId){
                self::writeServerItemStackId($out, $itemStackWrapper->getStackId());
            }
 
            self::putItemStackFooter($out, $itemStack);
        }
    }
 
    public static function getNetworkItemStackDescriptor(ByteBufferReader $in) : ItemStackWrapper{
        $id = LE::readSignedShort($in);
        $count = LE::readUnsignedShort($in);
        $meta = VarInt::readUnsignedInt($in);
 
        $hasNetId = self::getBool($in);
        if ($hasNetId) {
            $variant = VarInt::readUnsignedInt($in);
            $stackId = VarInt::readSignedInt($in);
        } else {
            $variant = 0;
            $stackId = 0;
        }
 
        $blockRuntimeId = VarInt::readUnsignedInt($in);
        $rawExtraData = self::getString($in);
 
        return new ItemStackWrapper($stackId, new ItemStack($id, $meta, $count, $blockRuntimeId, $rawExtraData), $variant);
    }
 
    public static function putNetworkItemStackDescriptor(ByteBufferWriter $out, ItemStackWrapper $itemStackWrapper) : void{
        LE::writeSignedShort($out, $itemStackWrapper->getItemStack()->getId());
        LE::writeUnsignedShort($out, $itemStackWrapper->getItemStack()->getCount());
        VarInt::writeUnsignedInt($out, $itemStackWrapper->getItemStack()->getMeta());
 
        self::putBool($out, $hasNetId = $itemStackWrapper->getStackId() !== 0);
        if($hasNetId){
            VarInt::writeUnsignedInt($out, $itemStackWrapper->getStackIdVariant());
            VarInt::writeSignedInt($out, $itemStackWrapper->getStackId());
        }
 
        VarInt::writeUnsignedInt($out, $itemStackWrapper->getItemStack()->getBlockRuntimeId());
        self::putString($out, $itemStackWrapper->getItemStack()->getRawExtraData());
    }
 
    public static function getRecipeIngredient(ByteBufferReader $in) : RecipeIngredient{
        $descriptorType = Byte::readUnsigned($in);
        $descriptor = match($descriptorType){
            ItemDescriptorType::INT_ID_META => IntIdMetaItemDescriptor::read($in),
            ItemDescriptorType::STRING_ID_META => StringIdMetaItemDescriptor::read($in),
            ItemDescriptorType::TAG => TagItemDescriptor::read($in),
            ItemDescriptorType::MOLANG => MolangItemDescriptor::read($in),
            ItemDescriptorType::COMPLEX_ALIAS => ComplexAliasItemDescriptor::read($in),
            default => null
        };
        $count = VarInt::readSignedInt($in);
 
        return new RecipeIngredient($descriptor, $count);
    }
 
    public static function putRecipeIngredient(ByteBufferWriter $out, RecipeIngredient $ingredient) : void{
        $type = $ingredient->getDescriptor();
 
        Byte::writeUnsigned($out, $type?->getTypeId() ?? 0);
        $type?->write($out);
 
        VarInt::writeSignedInt($out, $ingredient->getCount());
    }
 
    public static function getEntityMetadata(ByteBufferReader $in) : array{
        $count = VarInt::readUnsignedInt($in);
        $data = [];
        for($i = 0; $i < $count; ++$i){
            $key = VarInt::readUnsignedInt($in);
            $type = VarInt::readUnsignedInt($in);
 
            $data[$key] = self::readMetadataProperty($in, $type);
        }
 
        return $data;
    }
 
    private static function readMetadataProperty(ByteBufferReader $in, int $type) : MetadataProperty{
        return match($type){
            ByteMetadataProperty::ID => ByteMetadataProperty::read($in),
            ShortMetadataProperty::ID => ShortMetadataProperty::read($in),
            IntMetadataProperty::ID => IntMetadataProperty::read($in),
            FloatMetadataProperty::ID => FloatMetadataProperty::read($in),
            StringMetadataProperty::ID => StringMetadataProperty::read($in),
            CompoundTagMetadataProperty::ID => CompoundTagMetadataProperty::read($in),
            BlockPosMetadataProperty::ID => BlockPosMetadataProperty::read($in),
            LongMetadataProperty::ID => LongMetadataProperty::read($in),
            Vec3MetadataProperty::ID => Vec3MetadataProperty::read($in),
            default => throw new PacketDecodeException("Unknown entity metadata type " . $type),
        };
    }
 
    public static function putEntityMetadata(ByteBufferWriter $out, array $metadata) : void{
        VarInt::writeUnsignedInt($out, count($metadata));
        foreach($metadata as $key => $d){
            VarInt::writeUnsignedInt($out, $key);
            VarInt::writeUnsignedInt($out, $d->getTypeId());
            $d->write($out);
        }
    }
 
    public static function getActorUniqueId(ByteBufferReader $in) : int{
        return VarInt::readSignedLong($in);
    }
 
    public static function putActorUniqueId(ByteBufferWriter $out, int $eid) : void{
        VarInt::writeSignedLong($out, $eid);
    }
 
    public static function getActorRuntimeId(ByteBufferReader $in) : int{
        return VarInt::readUnsignedLong($in);
    }
 
    public static function putActorRuntimeId(ByteBufferWriter $out, int $eid) : void{
        VarInt::writeUnsignedLong($out, $eid);
    }
 
    public static function getBlockPosition(ByteBufferReader $in) : BlockPosition{
        $x = VarInt::readSignedInt($in);
        $y = VarInt::readSignedInt($in);
        $z = VarInt::readSignedInt($in);
        return new BlockPosition($x, $y, $z);
    }
 
    public static function putBlockPosition(ByteBufferWriter $out, BlockPosition $blockPosition) : void{
        VarInt::writeSignedInt($out, $blockPosition->getX());
        VarInt::writeSignedInt($out, $blockPosition->getY());
        VarInt::writeSignedInt($out, $blockPosition->getZ());
    }
 
    public static function getVector3(ByteBufferReader $in) : Vector3{
        $x = LE::readFloat($in);
        $y = LE::readFloat($in);
        $z = LE::readFloat($in);
        return new Vector3($x, $y, $z);
    }
 
    public static function getVector2(ByteBufferReader $in) : Vector2{
        $x = LE::readFloat($in);
        $y = LE::readFloat($in);
        return new Vector2($x, $y);
    }
 
    public static function putVector3Nullable(ByteBufferWriter $out, ?Vector3 $vector) : void{
        if($vector !== null){
            self::putVector3($out, $vector);
        }else{
            LE::writeFloat($out, 0.0);
            LE::writeFloat($out, 0.0);
            LE::writeFloat($out, 0.0);
        }
    }
 
    public static function putVector3(ByteBufferWriter $out, Vector3 $vector) : void{
        LE::writeFloat($out, $vector->x);
        LE::writeFloat($out, $vector->y);
        LE::writeFloat($out, $vector->z);
    }
 
    public static function putVector2(ByteBufferWriter $out, Vector2 $vector2) : void{
        LE::writeFloat($out, $vector2->x);
        LE::writeFloat($out, $vector2->y);
    }
 
    public static function getRotationByte(ByteBufferReader $in) : float{
        return Byte::readUnsigned($in) * (360 / 256);
    }
 
    public static function putRotationByte(ByteBufferWriter $out, float $rotation) : void{
        Byte::writeUnsigned($out, (int) ($rotation / (360 / 256)));
    }
 
    private static function readGameRule(ByteBufferReader $in, int $type, bool $isPlayerModifiable, bool $isStartGame) : GameRule{
        return match($type){
            BoolGameRule::ID => BoolGameRule::decode($in, $isPlayerModifiable),
            IntGameRule::ID => IntGameRule::decode($in, $isPlayerModifiable, $isStartGame),
            FloatGameRule::ID => FloatGameRule::decode($in, $isPlayerModifiable),
            default => throw new PacketDecodeException("Unknown gamerule type $type"),
        };
    }
 
    public static function getGameRules(ByteBufferReader $in, bool $isStartGame) : array{
        $count = VarInt::readUnsignedInt($in);
        $rules = [];
        for($i = 0; $i < $count; ++$i){
            $name = self::getString($in);
            $isPlayerModifiable = self::getBool($in);
            $type = VarInt::readUnsignedInt($in);
            $rules[$name] = self::readGameRule($in, $type, $isPlayerModifiable, $isStartGame);
        }
 
        return $rules;
    }
 
    public static function putGameRules(ByteBufferWriter $out, array $rules, bool $isStartGame) : void{
        VarInt::writeUnsignedInt($out, count($rules));
        foreach($rules as $name => $rule){
            self::putString($out, $name);
            self::putBool($out, $rule->isPlayerModifiable());
            VarInt::writeUnsignedInt($out, $rule->getTypeId());
            $rule->encode($out, $isStartGame);
        }
    }
 
    public static function getEntityLink(ByteBufferReader $in) : EntityLink{
        $fromActorUniqueId = self::getActorUniqueId($in);
        $toActorUniqueId = self::getActorUniqueId($in);
        $type = Byte::readUnsigned($in);
        $immediate = self::getBool($in);
        $causedByRider = self::getBool($in);
        $vehicleAngularVelocity = LE::readFloat($in);
        return new EntityLink($fromActorUniqueId, $toActorUniqueId, $type, $immediate, $causedByRider, $vehicleAngularVelocity);
    }
 
    public static function putEntityLink(ByteBufferWriter $out, EntityLink $link) : void{
        self::putActorUniqueId($out, $link->fromActorUniqueId);
        self::putActorUniqueId($out, $link->toActorUniqueId);
        Byte::writeUnsigned($out, $link->type);
        self::putBool($out, $link->immediate);
        self::putBool($out, $link->causedByRider);
        LE::writeFloat($out, $link->vehicleAngularVelocity);
    }
 
    public static function getCommandOriginData(ByteBufferReader $in) : CommandOriginData{
        $result = new CommandOriginData();
 
        $result->type = CommonTypes::getString($in);
        $result->uuid = self::getUUID($in);
        $result->requestId = self::getString($in);
        $result->playerActorUniqueId = LE::readSignedLong($in);
 
        return $result;
    }
 
    public static function putCommandOriginData(ByteBufferWriter $out, CommandOriginData $data) : void{
        self::putString($out, $data->type);
        self::putUUID($out, $data->uuid);
        self::putString($out, $data->requestId);
        LE::writeSignedLong($out, $data->playerActorUniqueId);
    }
 
    public static function getStructureSettings(ByteBufferReader $in) : StructureSettings{
        $result = new StructureSettings();
 
        $result->paletteName = self::getString($in);
 
        $result->ignoreEntities = self::getBool($in);
        $result->ignoreBlocks = self::getBool($in);
        $result->allowNonTickingChunks = self::getBool($in);
 
        $result->dimensions = self::getBlockPosition($in);
        $result->offset = self::getBlockPosition($in);
 
        $result->lastTouchedByPlayerID = self::getActorUniqueId($in);
        $result->rotation = Byte::readUnsigned($in);
        $result->mirror = Byte::readUnsigned($in);
        $result->animationMode = Byte::readUnsigned($in);
        $result->animationSeconds = LE::readFloat($in);
        $result->integrityValue = LE::readFloat($in);
        $result->integritySeed = LE::readUnsignedInt($in);
        $result->pivot = self::getVector3($in);
 
        return $result;
    }
 
    public static function putStructureSettings(ByteBufferWriter $out, StructureSettings $structureSettings) : void{
        self::putString($out, $structureSettings->paletteName);
 
        self::putBool($out, $structureSettings->ignoreEntities);
        self::putBool($out, $structureSettings->ignoreBlocks);
        self::putBool($out, $structureSettings->allowNonTickingChunks);
 
        self::putBlockPosition($out, $structureSettings->dimensions);
        self::putBlockPosition($out, $structureSettings->offset);
 
        self::putActorUniqueId($out, $structureSettings->lastTouchedByPlayerID);
        Byte::writeUnsigned($out, $structureSettings->rotation);
        Byte::writeUnsigned($out, $structureSettings->mirror);
        Byte::writeUnsigned($out, $structureSettings->animationMode);
        LE::writeFloat($out, $structureSettings->animationSeconds);
        LE::writeFloat($out, $structureSettings->integrityValue);
        LE::writeUnsignedInt($out, $structureSettings->integritySeed);
        self::putVector3($out, $structureSettings->pivot);
    }
 
    public static function getStructureEditorData(ByteBufferReader $in) : StructureEditorData{
        $result = new StructureEditorData();
 
        $result->structureName = self::getString($in);
        $result->filteredStructureName = self::getString($in);
        $result->structureDataField = self::getString($in);
 
        $result->includePlayers = self::getBool($in);
        $result->showBoundingBox = self::getBool($in);
 
        $result->structureBlockType = VarInt::readSignedInt($in);
        $result->structureSettings = self::getStructureSettings($in);
        $result->structureRedstoneSaveMode = VarInt::readSignedInt($in);
 
        return $result;
    }
 
    public static function putStructureEditorData(ByteBufferWriter $out, StructureEditorData $structureEditorData) : void{
        self::putString($out, $structureEditorData->structureName);
        self::putString($out, $structureEditorData->filteredStructureName);
        self::putString($out, $structureEditorData->structureDataField);
 
        self::putBool($out, $structureEditorData->includePlayers);
        self::putBool($out, $structureEditorData->showBoundingBox);
 
        VarInt::writeSignedInt($out, $structureEditorData->structureBlockType);
        self::putStructureSettings($out, $structureEditorData->structureSettings);
        VarInt::writeSignedInt($out, $structureEditorData->structureRedstoneSaveMode);
    }
 
    public static function getNbtRoot(ByteBufferReader $in) : TreeRoot{
        $offset = $in->getOffset();
        try{
            return (new NetworkNbtSerializer())->read($in->getData(), $offset, 512);
        }catch(NbtDataException $e){
            throw PacketDecodeException::wrap($e, "Failed decoding NBT root");
        }finally{
            $in->setOffset($offset);
        }
    }
 
    public static function getNbtCompoundRoot(ByteBufferReader $in) : CompoundTag{
        try{
            return self::getNbtRoot($in)->mustGetCompoundTag();
        }catch(NbtDataException $e){
            throw PacketDecodeException::wrap($e, "Expected TAG_Compound NBT root");
        }
    }
 
    public static function readRecipeNetId(ByteBufferReader $in) : int{
        return VarInt::readUnsignedInt($in);
    }
 
    public static function writeRecipeNetId(ByteBufferWriter $out, int $id) : void{
        VarInt::writeUnsignedInt($out, $id);
    }
 
    public static function readCreativeItemNetId(ByteBufferReader $in) : int{
        return VarInt::readUnsignedInt($in);
    }
 
    public static function writeCreativeItemNetId(ByteBufferWriter $out, int $id) : void{
        VarInt::writeUnsignedInt($out, $id);
    }
 
    public static function readItemStackNetIdVariant(ByteBufferReader $in) : int{
        return VarInt::readSignedInt($in);
    }
 
    public static function writeItemStackNetIdVariant(ByteBufferWriter $out, int $id) : void{
        VarInt::writeSignedInt($out, $id);
    }
 
    public static function readItemStackRequestId(ByteBufferReader $in) : int{
        return VarInt::readSignedInt($in);
    }
 
    public static function writeItemStackRequestId(ByteBufferWriter $out, int $id) : void{
        VarInt::writeSignedInt($out, $id);
    }
 
    public static function readLegacyItemStackRequestId(ByteBufferReader $in) : int{
        return VarInt::readSignedInt($in);
    }
 
    public static function writeLegacyItemStackRequestId(ByteBufferWriter $out, int $id) : void{
        VarInt::writeSignedInt($out, $id);
    }
 
    public static function readServerItemStackId(ByteBufferReader $in) : int{
        return VarInt::readSignedInt($in);
    }
 
    public static function writeServerItemStackId(ByteBufferWriter $out, int $id) : void{
        VarInt::writeSignedInt($out, $id);
    }
 
    public static function readOptional(ByteBufferReader $in, \Closure $reader) : mixed{
        if(self::getBool($in)){
            return $reader($in);
        }
        return null;
    }
 
    public static function writeOptional(ByteBufferWriter $out, mixed $value, \Closure $writer) : void{
        if($value !== null){
            self::putBool($out, true);
            $writer($out, $value);
        }else{
            self::putBool($out, false);
        }
    }
}