FastChunkSerializer.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\format\io;
 
use pocketmine\utils\Binary;
use pocketmine\utils\BinaryStream;
use pocketmine\world\format\Chunk;
use pocketmine\world\format\PalettedBlockArray;
use pocketmine\world\format\SubChunk;
use function array_values;
use function count;
use function pack;
use function strlen;
use function unpack;
 
final class FastChunkSerializer{
    private const FLAG_POPULATED = 1 << 1;
 
    private function __construct(){
        //NOOP
    }
 
    private static function serializePalettedArray(BinaryStream $stream, PalettedBlockArray $array) : void{
        $wordArray = $array->getWordArray();
        $palette = $array->getPalette();
 
        $stream->putByte($array->getBitsPerBlock());
        $stream->put($wordArray);
        $serialPalette = pack("L*", ...$palette);
        $stream->putInt(strlen($serialPalette));
        $stream->put($serialPalette);
    }
 
    public static function serializeTerrain(Chunk $chunk) : string{
        $stream = new BinaryStream();
        $stream->putByte(
            ($chunk->isPopulated() ? self::FLAG_POPULATED : 0)
        );
 
        //subchunks
        $subChunks = $chunk->getSubChunks();
        $count = count($subChunks);
        $stream->putByte($count);
 
        foreach($subChunks as $y => $subChunk){
            $stream->putByte($y);
            $stream->putInt($subChunk->getEmptyBlockId());
            $layers = $subChunk->getBlockLayers();
            $stream->putByte(count($layers));
            foreach($layers as $blocks){
                self::serializePalettedArray($stream, $blocks);
            }
            self::serializePalettedArray($stream, $subChunk->getBiomeArray());
 
        }
 
        return $stream->getBuffer();
    }
 
    private static function deserializePalettedArray(BinaryStream $stream) : PalettedBlockArray{
        $bitsPerBlock = $stream->getByte();
        $words = $stream->get(PalettedBlockArray::getExpectedWordArraySize($bitsPerBlock));
        $unpackedPalette = unpack("L*", $stream->get($stream->getInt())); //unpack() will never fail here
        $palette = array_values($unpackedPalette);
 
        return PalettedBlockArray::fromData($bitsPerBlock, $words, $palette);
    }
 
    public static function deserializeTerrain(string $data) : Chunk{
        $stream = new BinaryStream($data);
 
        $flags = $stream->getByte();
        $terrainPopulated = (bool) ($flags & self::FLAG_POPULATED);
 
        $subChunks = [];
 
        $count = $stream->getByte();
        for($subCount = 0; $subCount < $count; ++$subCount){
            $y = Binary::signByte($stream->getByte());
            $airBlockId = $stream->getInt();
 
            $layers = [];
            for($i = 0, $layerCount = $stream->getByte(); $i < $layerCount; ++$i){
                $layers[] = self::deserializePalettedArray($stream);
            }
            $biomeArray = self::deserializePalettedArray($stream);
            $subChunks[$y] = new SubChunk($airBlockId, $layers, $biomeArray);
        }
 
        return new Chunk($subChunks, $terrainPopulated);
    }
}