move RuntimeBlockMapping to convert package

src/network/mcpe/convert/RuntimeBlockMapping.php

@@ -0,0 +1,157 @@
+<?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\network\mcpe\convert;
+
+use pocketmine\block\BlockLegacyIds;
+use pocketmine\nbt\NBT;
+use pocketmine\nbt\tag\CompoundTag;
+use pocketmine\nbt\tag\ListTag;
+use pocketmine\network\mcpe\serializer\NetworkNbtSerializer;
+use function file_get_contents;
+use function getmypid;
+use function json_decode;
+use function mt_rand;
+use function mt_srand;
+use function shuffle;
+
+/**
+ * @internal
+ */
+final class RuntimeBlockMapping{
+	/** @var self|null */
+	private static $instance = null;
+
+	public static function getInstance() : self{
+		if(self::$instance === null){
+			self::$instance = new self;
+		}
+
+		return self::$instance;
+	}
+
+	/** @var int[] */
+	private $legacyToRuntimeMap = [];
+	/** @var int[] */
+	private $runtimeToLegacyMap = [];
+	/** @var CompoundTag[]|null */
+	private $bedrockKnownStates = null;
+
+	private function __construct(){
+		$tag = (new NetworkNbtSerializer())->read(file_get_contents(\pocketmine\RESOURCE_PATH . "vanilla/required_block_states.nbt"))->getTag();
+		if(!($tag instanceof ListTag) or $tag->getTagType() !== NBT::TAG_Compound){ //this is a little redundant currently, but good for auto complete and makes phpstan happy
+			throw new \RuntimeException("Invalid blockstates table, expected TAG_List<TAG_Compound> root");
+		}
+
+		/** @var CompoundTag[] $list */
+		$list = $tag->getValue();
+		$this->bedrockKnownStates = self::randomizeTable($list);
+
+		$this->setupLegacyMappings();
+	}
+
+	private function setupLegacyMappings() : void{
+		$legacyIdMap = json_decode(file_get_contents(\pocketmine\RESOURCE_PATH . "vanilla/block_id_map.json"), true);
+		$legacyStateMap = (new NetworkNbtSerializer())->read(file_get_contents(\pocketmine\RESOURCE_PATH . "vanilla/r12_to_current_block_map.nbt"))->getTag();
+		if(!($legacyStateMap instanceof ListTag) or $legacyStateMap->getTagType() !== NBT::TAG_Compound){
+			throw new \RuntimeException("Invalid legacy states mapping table, expected TAG_List<TAG_Compound> root");
+		}
+
+		/**
+		 * @var int[][] $idToStatesMap string id -> int[] list of candidate state indices
+		 */
+		$idToStatesMap = [];
+		foreach($this->bedrockKnownStates as $k => $state){
+			$idToStatesMap[$state->getCompoundTag("block")->getString("name")][] = $k;
+		}
+		/** @var CompoundTag $pair */
+		foreach($legacyStateMap as $pair){
+			$oldState = $pair->getCompoundTag("old");
+			$id = $legacyIdMap[$oldState->getString("name")];
+			$data = $oldState->getShort("val");
+			if($data > 15){
+				//we can't handle metadata with more than 4 bits
+				continue;
+			}
+			$mappedState = $pair->getCompoundTag("new");
+			$mappedName = $mappedState->getString("name");
+			if(!isset($idToStatesMap[$mappedName])){
+				throw new \RuntimeException("Mapped new state does not appear in network table");
+			}
+			foreach($idToStatesMap[$mappedName] as $k){
+				$networkState = $this->bedrockKnownStates[$k];
+				if($mappedState->equals($networkState->getCompoundTag("block"))){
+					$this->registerMapping($k, $id, $data);
+					continue 2;
+				}
+			}
+			throw new \RuntimeException("Mapped new state does not appear in network table");
+		}
+	}
+
+	/**
+	 * Randomizes the order of the runtimeID table to prevent plugins relying on them.
+	 * Plugins shouldn't use this stuff anyway, but plugin devs have an irritating habit of ignoring what they
+	 * aren't supposed to do, so we have to deliberately break it to make them stop.
+	 *
+	 * @param CompoundTag[] $table
+	 *
+	 * @return CompoundTag[]
+	 */
+	private static function randomizeTable(array $table) : array{
+		$postSeed = mt_rand(); //save a seed to set afterwards, to avoid poor quality randoms
+		mt_srand(getmypid()); //Use a seed which is the same on all threads. This isn't a secure seed, but we don't care.
+		shuffle($table);
+		mt_srand($postSeed); //restore a good quality seed that isn't dependent on PID
+		return $table;
+	}
+
+	public function toStaticRuntimeId(int $id, int $meta = 0) : int{
+		/*
+		 * try id+meta first
+		 * if not found, try id+0 (strip meta)
+		 * if still not found, return update! block
+		 */
+		return $this->legacyToRuntimeMap[($id << 4) | $meta] ?? $this->legacyToRuntimeMap[$id << 4] ?? $this->legacyToRuntimeMap[BlockLegacyIds::INFO_UPDATE << 4];
+	}
+
+	/**
+	 * @return int[] [id, meta]
+	 */
+	public function fromStaticRuntimeId(int $runtimeId) : array{
+		$v = $this->runtimeToLegacyMap[$runtimeId];
+		return [$v >> 4, $v & 0xf];
+	}
+
+	private function registerMapping(int $staticRuntimeId, int $legacyId, int $legacyMeta) : void{
+		$this->legacyToRuntimeMap[($legacyId << 4) | $legacyMeta] = $staticRuntimeId;
+		$this->runtimeToLegacyMap[$staticRuntimeId] = ($legacyId << 4) | $legacyMeta;
+	}
+
+	/**
+	 * @return CompoundTag[]
+	 */
+	public function getBedrockKnownStates() : array{
+		return $this->bedrockKnownStates;
+	}
+}