Merge branch 'stable'

src/network/mcpe/convert/ItemTranslator.php

@@ -0,0 +1,183 @@
+<?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\utils\AssumptionFailedError;
+use pocketmine\utils\SingletonTrait;
+use function array_key_exists;
+use function file_get_contents;
+use function is_array;
+use function is_numeric;
+use function is_string;
+use function json_decode;
+
+/**
+ * This class handles translation between network item ID+metadata to PocketMine-MP internal ID+metadata and vice versa.
+ */
+final class ItemTranslator{
+	use SingletonTrait;
+
+	/**
+	 * @var int[]
+	 * @phpstan-var array<int, int>
+	 */
+	private $simpleCoreToNetMapping = [];
+	/**
+	 * @var int[]
+	 * @phpstan-var array<int, int>
+	 */
+	private $simpleNetToCoreMapping = [];
+
+	/**
+	 * runtimeId = array[internalId][metadata]
+	 * @var int[][]
+	 * @phpstan-var array<int, array<int, int>>
+	 */
+	private $complexCoreToNetMapping = [];
+	/**
+	 * [internalId, metadata] = array[runtimeId]
+	 * @var int[][]
+	 * @phpstan-var array<int, array{int, int}>
+	 */
+	private $complexNetToCoreMapping = [];
+
+	private static function make() : self{
+		$data = file_get_contents(\pocketmine\RESOURCE_PATH . '/vanilla/r16_to_current_item_map.json');
+		if($data === false) throw new AssumptionFailedError("Missing required resource file");
+		$json = json_decode($data, true);
+		if(!is_array($json) or !isset($json["simple"], $json["complex"]) || !is_array($json["simple"]) || !is_array($json["complex"])){
+			throw new AssumptionFailedError("Invalid item table format");
+		}
+
+		$legacyStringToIntMapRaw = file_get_contents(\pocketmine\RESOURCE_PATH . '/vanilla/item_id_map.json');
+		if($legacyStringToIntMapRaw === false){
+			throw new AssumptionFailedError("Missing required resource file");
+		}
+		$legacyStringToIntMap = json_decode($legacyStringToIntMapRaw, true);
+		if(!is_array($legacyStringToIntMap)){
+			throw new AssumptionFailedError("Invalid mapping table format");
+		}
+
+		/** @phpstan-var array<string, int> $simpleMappings */
+		$simpleMappings = [];
+		foreach($json["simple"] as $oldId => $newId){
+			if(!is_string($oldId) || !is_string($newId)){
+				throw new AssumptionFailedError("Invalid item table format");
+			}
+			$simpleMappings[$newId] = $legacyStringToIntMap[$oldId];
+		}
+		foreach($legacyStringToIntMap as $stringId => $intId){
+			if(isset($simpleMappings[$stringId])){
+				throw new \UnexpectedValueException("Old ID $stringId collides with new ID");
+			}
+			$simpleMappings[$stringId] = $intId;
+		}
+
+		/** @phpstan-var array<string, array{int, int}> $complexMappings */
+		$complexMappings = [];
+		foreach($json["complex"] as $oldId => $map){
+			if(!is_string($oldId) || !is_array($map)){
+				throw new AssumptionFailedError("Invalid item table format");
+			}
+			foreach($map as $meta => $newId){
+				if(!is_numeric($meta) || !is_string($newId)){
+					throw new AssumptionFailedError("Invalid item table format");
+				}
+				$complexMappings[$newId] = [$legacyStringToIntMap[$oldId], (int) $meta];
+			}
+		}
+
+		return new self(ItemTypeDictionary::getInstance(), $simpleMappings, $complexMappings);
+	}
+
+	/**
+	 * @param int[] $simpleMappings
+	 * @param int[][] $complexMappings
+	 * @phpstan-param array<string, int> $simpleMappings
+	 * @phpstan-param array<string, array<int, int>> $complexMappings
+	 */
+	public function __construct(ItemTypeDictionary $dictionary, array $simpleMappings, array $complexMappings){
+		foreach($dictionary->getEntries() as $entry){
+			$stringId = $entry->getStringId();
+			$netId = $entry->getNumericId();
+			if(isset($complexMappings[$stringId])){
+				[$id, $meta] = $complexMappings[$stringId];
+				$this->complexCoreToNetMapping[$id][$meta] = $netId;
+				$this->complexNetToCoreMapping[$netId] = [$id, $meta];
+			}elseif(isset($simpleMappings[$stringId])){
+				$this->simpleCoreToNetMapping[$simpleMappings[$stringId]] = $netId;
+				$this->simpleNetToCoreMapping[$netId] = $simpleMappings[$stringId];
+			}elseif($stringId !== "minecraft:unknown"){
+				throw new \InvalidArgumentException("Unmapped entry " . $stringId);
+			}
+		}
+	}
+
+	/**
+	 * @return int[]
+	 * @phpstan-return array{int, int}
+	 */
+	public function toNetworkId(int $internalId, int $internalMeta) : array{
+		if(isset($this->complexCoreToNetMapping[$internalId][$internalMeta])){
+			return [$this->complexCoreToNetMapping[$internalId][$internalMeta], 0];
+		}
+		if(array_key_exists($internalId, $this->simpleCoreToNetMapping)){
+			return [$this->simpleCoreToNetMapping[$internalId], $internalMeta];
+		}
+
+		throw new \InvalidArgumentException("Unmapped ID/metadata combination $internalId:$internalMeta");
+	}
+
+	/**
+	 * @return int[]
+	 * @phpstan-return array{int, int}
+	 */
+	public function fromNetworkId(int $networkId, int $networkMeta, ?bool &$isComplexMapping = null) : array{
+		if(isset($this->complexNetToCoreMapping[$networkId])){
+			if($networkMeta !== 0){
+				throw new \UnexpectedValueException("Unexpected non-zero network meta on complex item mapping");
+			}
+			$isComplexMapping = true;
+			return $this->complexNetToCoreMapping[$networkId];
+		}
+		$isComplexMapping = false;
+		if(isset($this->simpleNetToCoreMapping[$networkId])){
+			return [$this->simpleNetToCoreMapping[$networkId], $networkMeta];
+		}
+		throw new \UnexpectedValueException("Unmapped network ID/metadata combination $networkId:$networkMeta");
+	}
+
+	/**
+	 * @return int[]
+	 * @phpstan-return array{int, int}
+	 */
+	public function fromNetworkIdWithWildcardHandling(int $networkId, int $networkMeta) : array{
+		$isComplexMapping = false;
+		if($networkMeta !== 0x7fff){
+			return $this->fromNetworkId($networkId, $networkMeta);
+		}
+		[$id, $meta] = $this->fromNetworkId($networkId, 0, $isComplexMapping);
+		return [$id, $isComplexMapping ? $meta : -1];
+	}
+}

src/network/mcpe/convert/ItemTypeDictionary.php

@@ -0,0 +1,106 @@
+<?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\network\mcpe\protocol\types\ItemTypeEntry;
+use pocketmine\utils\AssumptionFailedError;
+use pocketmine\utils\SingletonTrait;
+use function array_key_exists;
+use function file_get_contents;
+use function is_array;
+use function is_bool;
+use function is_int;
+use function is_string;
+use function json_decode;
+
+final class ItemTypeDictionary{
+	use SingletonTrait;
+
+	/**
+	 * @var ItemTypeEntry[]
+	 * @phpstan-var list<ItemTypeEntry>
+	 */
+	private $itemTypes;
+	/**
+	 * @var string[]
+	 * @phpstan-var array<int, string>
+	 */
+	private $intToStringIdMap = [];
+	/**
+	 * @var int[]
+	 * @phpstan-var array<string, int>
+	 */
+	private $stringToIntMap = [];
+
+	private static function make() : self{
+		$data = file_get_contents(\pocketmine\RESOURCE_PATH . '/vanilla/required_item_list.json');
+		if($data === false) throw new AssumptionFailedError("Missing required resource file");
+		$table = json_decode($data, true);
+		if(!is_array($table)){
+			throw new AssumptionFailedError("Invalid item list format");
+		}
+
+		$params = [];
+		foreach($table as $name => $entry){
+			if(!is_array($entry) || !is_string($name) || !isset($entry["component_based"], $entry["runtime_id"]) || !is_bool($entry["component_based"]) || !is_int($entry["runtime_id"])){
+				throw new AssumptionFailedError("Invalid item list format");
+			}
+			$params[] = new ItemTypeEntry($name, $entry["runtime_id"], $entry["component_based"]);
+		}
+		return new self($params);
+	}
+
+	/**
+	 * @param ItemTypeEntry[] $itemTypes
+	 */
+	public function __construct(array $itemTypes){
+		$this->itemTypes = $itemTypes;
+		foreach($this->itemTypes as $type){
+			$this->stringToIntMap[$type->getStringId()] = $type->getNumericId();
+			$this->intToStringIdMap[$type->getNumericId()] = $type->getStringId();
+		}
+	}
+
+	/**
+	 * @return ItemTypeEntry[]
+	 * @phpstan-return list<ItemTypeEntry>
+	 */
+	public function getEntries() : array{
+		return $this->itemTypes;
+	}
+
+	public function fromStringId(string $stringId) : int{
+		if(!array_key_exists($stringId, $this->stringToIntMap)){
+			throw new \InvalidArgumentException("Unmapped string ID \"$stringId\"");
+		}
+		return $this->stringToIntMap[$stringId];
+	}
+
+	public function fromIntId(int $intId) : string{
+		if(!array_key_exists($intId, $this->intToStringIdMap)){
+			throw new \InvalidArgumentException("Unmapped int ID $intId");
+		}
+		return $this->intToStringIdMap[$intId];
+	}
+}

src/network/mcpe/convert/RuntimeBlockMapping.php

@@ -25,18 +25,12 @@ namespace pocketmine\network\mcpe\convert;
 
 use pocketmine\block\BlockLegacyIds;
 use pocketmine\data\bedrock\LegacyBlockIdToStringIdMap;
-use pocketmine\nbt\NBT;
 use pocketmine\nbt\tag\CompoundTag;
-use pocketmine\nbt\tag\ListTag;
 use pocketmine\network\mcpe\protocol\serializer\NetworkNbtSerializer;
 use pocketmine\network\mcpe\protocol\serializer\PacketSerializer;
-use pocketmine\network\mcpe\protocol\types\CacheableNbt;
+use pocketmine\utils\AssumptionFailedError;
 use pocketmine\utils\SingletonTrait;
 use function file_get_contents;
-use function getmypid;
-use function mt_rand;
-use function mt_srand;
-use function shuffle;
 
 /**
  * @internal
@@ -50,21 +44,18 @@ final class RuntimeBlockMapping{
 	private $runtimeToLegacyMap = [];
 	/** @var CompoundTag[] */
 	private $bedrockKnownStates;
-	/**
-	 * @var CacheableNbt|null
-	 * @phpstan-var CacheableNbt<\pocketmine\nbt\tag\ListTag>|null
-	 */
-	private $startGamePaletteCache = 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");
+		$canonicalBlockStatesFile = file_get_contents(\pocketmine\RESOURCE_PATH . "vanilla/canonical_block_states.nbt");
+		if($canonicalBlockStatesFile === false){
+			throw new AssumptionFailedError("Missing required resource file");
 		}
-
-		/** @var CompoundTag[] $list */
-		$list = $tag->getValue();
-		$this->bedrockKnownStates = self::randomizeTable($list);
+		$stream = new PacketSerializer($canonicalBlockStatesFile);
+		$list = [];
+		while(!$stream->feof()){
+			$list[] = $stream->getNbtCompoundRoot();
+		}
+		$this->bedrockKnownStates = $list;
 
 		$this->setupLegacyMappings();
 	}
@@ -90,7 +81,7 @@ final class RuntimeBlockMapping{
 		 */
 		$idToStatesMap = [];
 		foreach($this->bedrockKnownStates as $k => $state){
-			$idToStatesMap[$state->getCompoundTag("block")->getString("name")][] = $k;
+			$idToStatesMap[$state->getString("name")][] = $k;
 		}
 		foreach($legacyStateMap as $pair){
 			$id = $legacyIdMap->stringToLegacy($pair->getId()) ?? null;
@@ -109,7 +100,7 @@ final class RuntimeBlockMapping{
 			}
 			foreach($idToStatesMap[$mappedName] as $k){
 				$networkState = $this->bedrockKnownStates[$k];
-				if($mappedState->equals($networkState->getCompoundTag("block"))){
+				if($mappedState->equals($networkState)){
 					$this->registerMapping($k, $id, $data);
 					continue 2;
 				}
@@ -118,23 +109,6 @@ final class RuntimeBlockMapping{
 		}
 	}
 
-	/**
-	 * 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 toRuntimeId(int $internalStateId) : int{
 		return $this->legacyToRuntimeMap[$internalStateId] ?? $this->legacyToRuntimeMap[BlockLegacyIds::INFO_UPDATE << 4];
 	}
@@ -146,7 +120,6 @@ final class RuntimeBlockMapping{
 	private function registerMapping(int $staticRuntimeId, int $legacyId, int $legacyMeta) : void{
 		$this->legacyToRuntimeMap[($legacyId << 4) | $legacyMeta] = $staticRuntimeId;
 		$this->runtimeToLegacyMap[$staticRuntimeId] = ($legacyId << 4) | $legacyMeta;
-		$this->startGamePaletteCache = null;
 	}
 
 	/**
@@ -155,11 +128,4 @@ final class RuntimeBlockMapping{
 	public function getBedrockKnownStates() : array{
 		return $this->bedrockKnownStates;
 	}
-
-	/**
-	 * @phpstan-return CacheableNbt<\pocketmine\nbt\tag\ListTag>
-	 */
-	public function getStartGamePaletteCache() : CacheableNbt{
-		return $this->startGamePaletteCache ?? ($this->startGamePaletteCache = new CacheableNbt(new ListTag($this->bedrockKnownStates)));
-	}
 }

src/network/mcpe/convert/TypeConverter.php

@@ -55,6 +55,14 @@ class TypeConverter{
 	private const DAMAGE_TAG = "Damage"; //TAG_Int
 	private const DAMAGE_TAG_CONFLICT_RESOLUTION = "___Damage_ProtocolCollisionResolution___";
 
+	/** @var int */
+	private $shieldRuntimeId;
+
+	public function __construct(){
+		//TODO: inject stuff via constructor
+		$this->shieldRuntimeId = ItemTypeDictionary::getInstance()->fromStringId("minecraft:shield");
+	}
+
 	/**
 	 * Returns a client-friendly gamemode of the specified real gamemode
 	 * This function takes care of handling gamemodes known to MCPE (as of 1.1.0.3, that includes Survival, Creative and Adventure)
@@ -92,16 +100,30 @@ class TypeConverter{
 	}
 
 	public function coreItemStackToRecipeIngredient(Item $itemStack) : RecipeIngredient{
-		$meta = $itemStack->getMeta();
-		return new RecipeIngredient($itemStack->getId(), $meta === -1 ? 0x7fff : $meta, $itemStack->getCount());
+		if($itemStack->isNull()){
+			return new RecipeIngredient(0, 0, 0);
+		}
+		if($itemStack->hasAnyDamageValue()){
+			[$id, ] = ItemTranslator::getInstance()->toNetworkId($itemStack->getId(), 0);
+			$meta = 0x7fff;
+		}else{
+			[$id, $meta] = ItemTranslator::getInstance()->toNetworkId($itemStack->getId(), $itemStack->getMeta());
+		}
+		return new RecipeIngredient($id, $meta, $itemStack->getCount());
 	}
 
 	public function recipeIngredientToCoreItemStack(RecipeIngredient $ingredient) : Item{
-		$meta = $ingredient->getMeta();
-		return ItemFactory::getInstance()->get($ingredient->getId(), $meta === 0x7fff ? -1 : $meta, $ingredient->getCount());
+		if($ingredient->getId() === 0){
+			return ItemFactory::getInstance()->get(ItemIds::AIR, 0, 0);
+		}
+		[$id, $meta] = ItemTranslator::getInstance()->fromNetworkIdWithWildcardHandling($ingredient->getId(), $ingredient->getMeta());
+		return ItemFactory::getInstance()->get($id, $meta, $ingredient->getCount());
 	}
 
 	public function coreItemStackToNet(Item $itemStack) : ItemStack{
+		if($itemStack->isNull()){
+			return ItemStack::null();
+		}
 		$nbt = null;
 		if($itemStack->hasNamedTag()){
 			$nbt = clone $itemStack->getNamedTag();
@@ -117,23 +139,26 @@ class TypeConverter{
 			}
 			$nbt->setInt(self::DAMAGE_TAG, $itemStack->getDamage());
 		}
-		$id = $itemStack->getId();
-		$meta = $itemStack->getMeta();
+		[$id, $meta] = ItemTranslator::getInstance()->toNetworkId($itemStack->getId(), $itemStack->getMeta());
 
 		return new ItemStack(
 			$id,
-			$meta === -1 ? 0x7fff : $meta,
+			$meta,
 			$itemStack->getCount(),
 			$nbt,
 			[],
 			[],
-			$id === ItemIds::SHIELD ? 0 : null
+			$id === $this->shieldRuntimeId ? 0 : null
 		);
 	}
 
 	public function netItemStackToCore(ItemStack $itemStack) : Item{
+		if($itemStack->getId() === 0){
+			return ItemFactory::getInstance()->get(ItemIds::AIR, 0, 0);
+		}
 		$compound = $itemStack->getNbt();
-		$meta = $itemStack->getMeta();
+
+		[$id, $meta] = ItemTranslator::getInstance()->fromNetworkId($itemStack->getId(), $itemStack->getMeta());
 
 		if($compound !== null){
 			$compound = clone $compound;
@@ -153,8 +178,8 @@ class TypeConverter{
 
 		end:
 		return ItemFactory::getInstance()->get(
-			$itemStack->getId(),
-			$meta !== 0x7fff ? $meta : -1,
+			$id,
+			$meta,
 			$itemStack->getCount(),
 			$compound
 		);