LevelChunkPacket.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;
 
use pmmp\encoding\ByteBufferReader;
use pmmp\encoding\ByteBufferWriter;
use pmmp\encoding\LE;
use pmmp\encoding\VarInt;
use pocketmine\network\mcpe\protocol\serializer\CommonTypes;
use pocketmine\network\mcpe\protocol\types\ChunkPosition;
use pocketmine\network\mcpe\protocol\types\DimensionIds;
use pocketmine\utils\Limits;
use function count;
use const PHP_INT_MAX;
 
class LevelChunkPacket extends DataPacket implements ClientboundPacket{
    public const NETWORK_ID = ProtocolInfo::LEVEL_CHUNK_PACKET;
 
    private const CLIENT_REQUEST_FULL_COLUMN_FAKE_COUNT = Limits::UINT32_MAX;
    private const CLIENT_REQUEST_TRUNCATED_COLUMN_FAKE_COUNT = Limits::UINT32_MAX - 1;
 
    //this appears large enough for a world height of 1024 blocks - it may need to be increased in the future
    private const MAX_BLOB_HASHES = 64;
 
    private ChunkPosition $chunkPosition;
    private int $dimensionId;
    private int $subChunkCount;
    private bool $clientSubChunkRequestsEnabled;
    private ?array $usedBlobHashes = null;
    private string $extraPayload;
 
    public static function create(ChunkPosition $chunkPosition, int $dimensionId, int $subChunkCount, bool $clientSubChunkRequestsEnabled, ?array $usedBlobHashes, string $extraPayload) : self{
        $result = new self;
        $result->chunkPosition = $chunkPosition;
        $result->dimensionId = $dimensionId;
        $result->subChunkCount = $subChunkCount;
        $result->clientSubChunkRequestsEnabled = $clientSubChunkRequestsEnabled;
        $result->usedBlobHashes = $usedBlobHashes;
        $result->extraPayload = $extraPayload;
        return $result;
    }
 
    public function getChunkPosition() : ChunkPosition{ return $this->chunkPosition; }
 
    public function getDimensionId() : int{ return $this->dimensionId; }
 
    public function getSubChunkCount() : int{
        return $this->subChunkCount;
    }
 
    public function isClientSubChunkRequestsEnabled() : bool{
        return $this->clientSubChunkRequestsEnabled;
    }
 
    public function isClientSubChunkRequestEnabled() : bool{
        return $this->clientSubChunkRequestsEnabled;
    }
 
    public function isCacheEnabled() : bool{
        return $this->usedBlobHashes !== null;
    }
 
    public function getUsedBlobHashes() : ?array{
        return $this->usedBlobHashes;
    }
 
    public function getExtraPayload() : string{
        return $this->extraPayload;
    }
 
    protected function decodePayload(ByteBufferReader $in) : void{
        $this->chunkPosition = ChunkPosition::read($in);
        $this->dimensionId = VarInt::readSignedInt($in);
 
        $subChunkCountButNotReally = VarInt::readUnsignedInt($in);
        if($subChunkCountButNotReally === self::CLIENT_REQUEST_FULL_COLUMN_FAKE_COUNT){
            $this->clientSubChunkRequestsEnabled = true;
            $this->subChunkCount = PHP_INT_MAX;
        }elseif($subChunkCountButNotReally === self::CLIENT_REQUEST_TRUNCATED_COLUMN_FAKE_COUNT){
            $this->clientSubChunkRequestsEnabled = true;
            $this->subChunkCount = LE::readUnsignedShort($in);
        }else{
            $this->clientSubChunkRequestsEnabled = false;
            $this->subChunkCount = $subChunkCountButNotReally;
        }
 
        $cacheEnabled = CommonTypes::getBool($in);
        if($cacheEnabled){
            $this->usedBlobHashes = [];
            $count = VarInt::readUnsignedInt($in);
            if($count > self::MAX_BLOB_HASHES){
                throw new PacketDecodeException("Expected at most " . self::MAX_BLOB_HASHES . " blob hashes, got " . $count);
            }
            for($i = 0; $i < $count; ++$i){
                $this->usedBlobHashes[] = LE::readUnsignedLong($in);
            }
        }
        $this->extraPayload = CommonTypes::getString($in);
    }
 
    protected function encodePayload(ByteBufferWriter $out) : void{
        $this->chunkPosition->write($out);
        VarInt::writeSignedInt($out, $this->dimensionId);
 
        if($this->clientSubChunkRequestsEnabled){
            if($this->subChunkCount === PHP_INT_MAX){
                VarInt::writeUnsignedInt($out, self::CLIENT_REQUEST_FULL_COLUMN_FAKE_COUNT);
            }else{
                VarInt::writeUnsignedInt($out, self::CLIENT_REQUEST_TRUNCATED_COLUMN_FAKE_COUNT);
                LE::writeUnsignedShort($out, $this->subChunkCount);
            }
        }else{
            VarInt::writeUnsignedInt($out, $this->subChunkCount);
        }
 
        CommonTypes::putBool($out, $this->usedBlobHashes !== null);
        if($this->usedBlobHashes !== null){
            VarInt::writeUnsignedInt($out, count($this->usedBlobHashes));
            foreach($this->usedBlobHashes as $hash){
                LE::writeUnsignedLong($out, $hash);
            }
        }
        CommonTypes::putString($out, $this->extraPayload);
    }
 
    public function handle(PacketHandlerInterface $handler) : bool{
        return $handler->handleLevelChunk($this);
    }
}