mirrors/PocketMine-MP
1
0
Fork 0
mirror of https://github.com/pmmp/PocketMine-MP.git synced 2025-06-03 18:42:37 +00:00
Code Issues Projects Releases Wiki Activity

Add support for specialized flattenedProperties in schema format

Browse Source
This commit is contained in:
Dylan K. Taylor 2024-10-24 16:12:28 +01:00
parent acbfb0a3e9
commit 22718c4971
No known key found for this signature in database
GPG Key ID: 8927471A91CAFD3D
10 changed files with 251 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/data/bedrock/block/upgrade/BlockStateUpgradeSchema.php
View File

@ -23,6 +23,7 @@ declare(strict_types=1);
namespace pocketmine\data\bedrock\block\upgrade;
use pocketmine\data\bedrock\block\upgrade\BlockStateUpgradeSchemaFlattenInfo as FlattenInfo;
use pocketmine\data\bedrock\block\upgrade\BlockStateUpgradeSchemaValueRemap as ValueRemap;
use pocketmine\nbt\tag\Tag;
use function count;
@ -58,6 +59,12 @@ final class BlockStateUpgradeSchema{
*/
public array $remappedPropertyValues = [];
/**
* @var FlattenInfo[]
* @phpstan-var array<string, FlattenInfo>
*/
public array $flattenedProperties = [];
/**
* @var BlockStateUpgradeSchemaBlockRemap[][]
* @phpstan-var array<string, list<BlockStateUpgradeSchemaBlockRemap>>
@ -93,6 +100,7 @@ final class BlockStateUpgradeSchema{
$this->removedProperties,
$this->renamedProperties,
$this->remappedPropertyValues,
$this->flattenedProperties,
$this->remappedStates,
] as $list){
if(count($list) !== 0){

6
src/data/bedrock/block/upgrade/BlockStateUpgradeSchemaBlockRemap.php
View File

@ -40,7 +40,7 @@ final class BlockStateUpgradeSchemaBlockRemap{
*/
public function __construct(
public array $oldState,
public string|BlockStateUpgradeSchemaFlattenedName $newName,
public string|BlockStateUpgradeSchemaFlattenInfo $newName,
public array $newState,
public array $copiedState
){}
@ -48,8 +48,8 @@ final class BlockStateUpgradeSchemaBlockRemap{
public function equals(self $that) : bool{
$sameName = $this->newName === $that->newName ||
(
$this->newName instanceof BlockStateUpgradeSchemaFlattenedName &&
$that->newName instanceof BlockStateUpgradeSchemaFlattenedName &&
$this->newName instanceof BlockStateUpgradeSchemaFlattenInfo &&
$that->newName instanceof BlockStateUpgradeSchemaFlattenInfo &&
$this->newName->equals($that->newName)
);
if(!$sameName){

2
src/data/bedrock/block/upgrade/BlockStateUpgradeSchemaFlattenedName.php → src/data/bedrock/block/upgrade/BlockStateUpgradeSchemaFlattenInfo.php
View File

@ -29,7 +29,7 @@ use pocketmine\nbt\tag\StringTag;
use function ksort;
use const SORT_STRING;
final class BlockStateUpgradeSchemaFlattenedName{
final class BlockStateUpgradeSchemaFlattenInfo{
/**
* @param string[] $flattenedValueRemaps

71
src/data/bedrock/block/upgrade/BlockStateUpgradeSchemaUtils.php
View File

@ -25,7 +25,7 @@ namespace pocketmine\data\bedrock\block\upgrade;
use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModel;
use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelBlockRemap;
use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelFlattenedName;
use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelFlattenInfo;
use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelTag;
use pocketmine\data\bedrock\block\upgrade\model\BlockStateUpgradeSchemaModelValueRemap;
use pocketmine\nbt\tag\ByteTag;
@ -155,24 +155,17 @@ final class BlockStateUpgradeSchemaUtils{
}
}
foreach(Utils::stringifyKeys($model->flattenedProperties ?? []) as $blockName => $flattenRule){
$result->flattenedProperties[$blockName] = self::jsonModelToFlattenRule($flattenRule);
}
foreach(Utils::stringifyKeys($model->remappedStates ?? []) as $oldBlockName => $remaps){
foreach($remaps as $remap){
if(isset($remap->newName)){
$remapName = $remap->newName;
}elseif(isset($remap->newFlattenedName)){
$flattenRule = $remap->newFlattenedName;
$remapName = new BlockStateUpgradeSchemaFlattenedName(
$flattenRule->prefix,
$flattenRule->flattenedProperty,
$flattenRule->suffix,
$flattenRule->flattenedValueRemaps ?? [],
match($flattenRule->flattenedPropertyType){
"string", null => StringTag::class,
"int" => IntTag::class,
"byte" => ByteTag::class,
default => throw new \UnexpectedValueException("Unexpected flattened property type $flattenRule->flattenedPropertyType, expected 'string', 'int' or 'byte'")
}
);
$remapName = self::jsonModelToFlattenRule($flattenRule);
}else{
throw new \UnexpectedValueException("Expected exactly one of 'newName' or 'newFlattenedName' properties to be set");
}
@ -265,6 +258,36 @@ final class BlockStateUpgradeSchemaUtils{
$model->remappedPropertyValues = $modelDedupMapping;
}
private static function flattenRuleToJsonModel(BlockStateUpgradeSchemaFlattenInfo $flattenRule) : BlockStateUpgradeSchemaModelFlattenInfo{
return new BlockStateUpgradeSchemaModelFlattenInfo(
$flattenRule->prefix,
$flattenRule->flattenedProperty,
$flattenRule->suffix,
$flattenRule->flattenedValueRemaps,
match($flattenRule->flattenedPropertyType){
StringTag::class => null, //omit for TAG_String, as this is the common case
ByteTag::class => "byte",
IntTag::class => "int",
default => throw new \LogicException("Unexpected tag type " . $flattenRule->flattenedPropertyType . " in flattened property type")
}
);
}
private static function jsonModelToFlattenRule(BlockStateUpgradeSchemaModelFlattenInfo $flattenRule) : BlockStateUpgradeSchemaFlattenInfo{
return new BlockStateUpgradeSchemaFlattenInfo(
$flattenRule->prefix,
$flattenRule->flattenedProperty,
$flattenRule->suffix,
$flattenRule->flattenedValueRemaps ?? [],
match ($flattenRule->flattenedPropertyType) {
"string", null => StringTag::class,
"int" => IntTag::class,
"byte" => ByteTag::class,
default => throw new \UnexpectedValueException("Unexpected flattened property type $flattenRule->flattenedPropertyType, expected 'string', 'int' or 'byte'")
}
);
}
public static function toJsonModel(BlockStateUpgradeSchema $schema) : BlockStateUpgradeSchemaModel{
$result = new BlockStateUpgradeSchemaModel();
$result->maxVersionMajor = $schema->maxVersionMajor;
@ -303,25 +326,19 @@ final class BlockStateUpgradeSchemaUtils{
self::buildRemappedValuesIndex($schema, $result);
foreach(Utils::stringifyKeys($schema->flattenedProperties) as $blockName => $flattenRule){
$result->flattenedProperties[$blockName] = self::flattenRuleToJsonModel($flattenRule);
}
if(isset($result->flattenedProperties)){
ksort($result->flattenedProperties);
}
foreach(Utils::stringifyKeys($schema->remappedStates) as $oldBlockName => $remaps){
$keyedRemaps = [];
foreach($remaps as $remap){
$modelRemap = new BlockStateUpgradeSchemaModelBlockRemap(
array_map(fn(Tag $tag) => self::tagToJsonModel($tag), $remap->oldState),
is_string($remap->newName) ?
$remap->newName :
new BlockStateUpgradeSchemaModelFlattenedName(
$remap->newName->prefix,
$remap->newName->flattenedProperty,
$remap->newName->suffix,
$remap->newName->flattenedValueRemaps,
match($remap->newName->flattenedPropertyType){
StringTag::class => null, //omit for TAG_String, as this is the common case
ByteTag::class => "byte",
IntTag::class => "int",
default => throw new \LogicException("Unexpected tag type " . $remap->newName->flattenedPropertyType . " in flattened property type")
}
),
is_string($remap->newName) ? $remap->newName : self::flattenRuleToJsonModel($remap->newName),
array_map(fn(Tag $tag) => self::tagToJsonModel($tag), $remap->newState),
$remap->copiedState
);

62
src/data/bedrock/block/upgrade/BlockStateUpgrader.php
View File

@ -110,10 +110,21 @@ final class BlockStateUpgrader{
}
$oldName = $blockStateData->getName();
$newName = $schema->renamedIds[$oldName] ?? null;
$states = $blockStateData->getStates();
if(isset($schema->renamedIds[$oldName]) && isset($schema->flattenedProperties[$oldName])){
//TODO: this probably ought to be validated when the schema is constructed
throw new AssumptionFailedError("Both renamedIds and flattenedProperties are set for the same block ID \"$oldName\" - don't know what to do");
}
if(isset($schema->renamedIds[$oldName])){
$newName = $schema->renamedIds[$oldName] ?? null;
}elseif(isset($schema->flattenedProperties[$oldName])){
[$newName, $states] = $this->applyPropertyFlattened($schema->flattenedProperties[$oldName], $oldName, $states);
}else{
$newName = null;
}
$stateChanges = 0;
$states = $blockStateData->getStates();
$states = $this->applyPropertyAdded($schema, $oldName, $states, $stateChanges);
$states = $this->applyPropertyRemoved($schema, $oldName, $states, $stateChanges);
@ -146,22 +157,9 @@ final class BlockStateUpgrader{
if(is_string($remap->newName)){
$newName = $remap->newName;
}else{
$flattenedValue = $oldState[$remap->newName->flattenedProperty] ?? null;
$expectedType = $remap->newName->flattenedPropertyType;
if(!$flattenedValue instanceof $expectedType){
//flattened property is not of the expected type, so this transformation is not applicable
continue;
}
$embedKey = match(get_class($flattenedValue)){
StringTag::class => $flattenedValue->getValue(),
ByteTag::class => (string) $flattenedValue->getValue(),
IntTag::class => (string) $flattenedValue->getValue(),
//flattenedPropertyType is always one of these three types, but PHPStan doesn't know that
default => throw new AssumptionFailedError("flattenedPropertyType should be one of these three types, but have " . get_class($flattenedValue)),
};
$embedValue = $remap->newName->flattenedValueRemaps[$embedKey] ?? $embedKey;
$newName = sprintf("%s%s%s", $remap->newName->prefix, $embedValue, $remap->newName->suffix);
unset($oldState[$remap->newName->flattenedProperty]);
//yes, overwriting $oldState here is intentional, although we probably don't actually need it anyway
//it shouldn't make any difference unless the flattened property appears in copiedState for some reason
[$newName, $oldState] = $this->applyPropertyFlattened($remap->newName, $oldName, $oldState);
}
$newState = $remap->newState;
@ -279,4 +277,32 @@ final class BlockStateUpgrader{
return $states;
}
/**
* @param Tag[] $states
* @phpstan-param array<string, Tag> $states
*
* @return (string|Tag[])[]
* @phpstan-return array{0: string, 1: array<string, Tag>}
*/
private function applyPropertyFlattened(BlockStateUpgradeSchemaFlattenInfo $flattenInfo, string $oldName, array $states) : array{
$flattenedValue = $states[$flattenInfo->flattenedProperty] ?? null;
$expectedType = $flattenInfo->flattenedPropertyType;
if(!$flattenedValue instanceof $expectedType){
//flattened property is not of the expected type, so this transformation is not applicable
return [$oldName, $states];
}
$embedKey = match(get_class($flattenedValue)){
StringTag::class => $flattenedValue->getValue(),
ByteTag::class => (string) $flattenedValue->getValue(),
IntTag::class => (string) $flattenedValue->getValue(),
//flattenedPropertyType is always one of these three types, but PHPStan doesn't know that
default => throw new AssumptionFailedError("flattenedPropertyType should be one of these three types, but have " . get_class($flattenedValue)),
};
$embedValue = $flattenInfo->flattenedValueRemaps[$embedKey] ?? $embedKey;
$newName = sprintf("%s%s%s", $flattenInfo->prefix, $embedValue, $flattenInfo->suffix);
unset($states[$flattenInfo->flattenedProperty]);
return [$newName, $states];
}
}

6
src/data/bedrock/block/upgrade/model/BlockStateUpgradeSchemaModel.php
View File

@ -75,6 +75,12 @@ final class BlockStateUpgradeSchemaModel implements \JsonSerializable{
*/
public array $remappedPropertyValuesIndex;
/**
* @var BlockStateUpgradeSchemaModelFlattenInfo[]
* @phpstan-var array<string, BlockStateUpgradeSchemaModelFlattenInfo>
*/
public array $flattenedProperties;
/**
* @var BlockStateUpgradeSchemaModelBlockRemap[][]
* @phpstan-var array<string, list<BlockStateUpgradeSchemaModelBlockRemap>>

6
src/data/bedrock/block/upgrade/model/BlockStateUpgradeSchemaModelBlockRemap.php
View File

@ -43,7 +43,7 @@ final class BlockStateUpgradeSchemaModelBlockRemap{
* Either this or newName must be present
* Due to technical limitations of jsonmapper, we can't use a union type here
*/
public BlockStateUpgradeSchemaModelFlattenedName $newFlattenedName;
public BlockStateUpgradeSchemaModelFlattenInfo $newFlattenedName;
/**
* @var BlockStateUpgradeSchemaModelTag[]|null
@ -67,9 +67,9 @@ final class BlockStateUpgradeSchemaModelBlockRemap{
* @phpstan-param array<string, BlockStateUpgradeSchemaModelTag> $newState
* @phpstan-param list<string> $copiedState
*/
public function __construct(array $oldState, string|BlockStateUpgradeSchemaModelFlattenedName $newNameRule, array $newState, array $copiedState){
public function __construct(array $oldState, string|BlockStateUpgradeSchemaModelFlattenInfo $newNameRule, array $newState, array $copiedState){
$this->oldState = count($oldState) === 0 ? null : $oldState;
if($newNameRule instanceof BlockStateUpgradeSchemaModelFlattenedName){
if($newNameRule instanceof BlockStateUpgradeSchemaModelFlattenInfo){
$this->newFlattenedName = $newNameRule;
}else{
$this->newName = $newNameRule;

2
src/data/bedrock/block/upgrade/model/BlockStateUpgradeSchemaModelFlattenedName.php → src/data/bedrock/block/upgrade/model/BlockStateUpgradeSchemaModelFlattenInfo.php
View File

@ -25,7 +25,7 @@ namespace pocketmine\data\bedrock\block\upgrade\model;
use function count;
final class BlockStateUpgradeSchemaModelFlattenedName implements \JsonSerializable{
final class BlockStateUpgradeSchemaModelFlattenInfo implements \JsonSerializable{
/** @required */
public string $prefix;

19
tests/phpunit/data/bedrock/block/upgrade/BlockStateUpgraderTest.php
View File

@ -24,8 +24,10 @@ declare(strict_types=1);
namespace pocketmine\data\bedrock\block\upgrade;
use PHPUnit\Framework\TestCase;
use pocketmine\block\Block;
use pocketmine\data\bedrock\block\BlockStateData;
use pocketmine\nbt\tag\IntTag;
use pocketmine\nbt\tag\StringTag;
use const PHP_INT_MAX;
class BlockStateUpgraderTest extends TestCase{
@ -210,6 +212,23 @@ class BlockStateUpgraderTest extends TestCase{
self::assertSame($upgradedStateData->getState(self::TEST_PROPERTY_2)?->getValue(), $valueAfter);
}
public function testFlattenProperty() : void{
$schema = $this->getNewSchema();
$schema->flattenedProperties[self::TEST_BLOCK] = new BlockStateUpgradeSchemaFlattenInfo(
"minecraft:",
"test",
"_suffix",
[],
StringTag::class
);
$stateData = new BlockStateData(self::TEST_BLOCK, ["test" => new StringTag("value1")], 0);
$upgradedStateData = $this->upgrade($stateData, fn() => $stateData);
self::assertSame("minecraft:value1_suffix", $upgradedStateData->getName());
self::assertEmpty($upgradedStateData->getStates());
}
/**
* @phpstan-return \Generator<int, array{int, int, bool, int}, void, void>
*/

170
tools/blockstate-upgrade-schema-utils.php
View File

@ -27,7 +27,7 @@ use pocketmine\data\bedrock\block\BlockStateData;
use pocketmine\data\bedrock\block\upgrade\BlockStateUpgrader;
use pocketmine\data\bedrock\block\upgrade\BlockStateUpgradeSchema;
use pocketmine\data\bedrock\block\upgrade\BlockStateUpgradeSchemaBlockRemap;
use pocketmine\data\bedrock\block\upgrade\BlockStateUpgradeSchemaFlattenedName;
use pocketmine\data\bedrock\block\upgrade\BlockStateUpgradeSchemaFlattenInfo;
use pocketmine\data\bedrock\block\upgrade\BlockStateUpgradeSchemaUtils;
use pocketmine\data\bedrock\block\upgrade\BlockStateUpgradeSchemaValueRemap;
use pocketmine\nbt\LittleEndianNbtSerializer;
@ -183,6 +183,11 @@ function processStateGroup(string $oldName, array $upgradeTable, BlockStateUpgra
$removedProperties = [];
$renamedProperties = [];
$uniqueNewIds = [];
foreach($upgradeTable as $pair){
$uniqueNewIds[$pair->new->getName()] = $pair->new->getName();
}
foreach(Utils::stringifyKeys($newProperties) as $newPropertyName => $newPropertyValues){
if(count($newPropertyValues) === 1){
$newPropertyValue = $newPropertyValues[array_key_first($newPropertyValues)];
@ -278,6 +283,61 @@ function processStateGroup(string $oldName, array $upgradeTable, BlockStateUpgra
}
}
if(count($uniqueNewIds) > 1){
//detect possible flattening
$flattenedProperty = null;
$flattenedPropertyType = null;
$flattenedPropertyMap = [];
foreach($removedProperties as $removedProperty){
$valueMap = [];
foreach($upgradeTable as $pair){
$oldValue = $pair->old->getState($removedProperty);
if($oldValue === null){
throw new AssumptionFailedError("We already checked that all states had consistent old properties");
}
//TODO: lots of similar logic to the remappedStates builder below
if(!$oldValue instanceof ByteTag && !$oldValue instanceof IntTag && !$oldValue instanceof StringTag){
//unknown property type - bad candidate for flattening
continue 2;
}
if($flattenedPropertyType === null){
$flattenedPropertyType = get_class($oldValue);
}elseif(!$oldValue instanceof $flattenedPropertyType){
//property type mismatch - bad candidate for flattening
continue 2;
}
$rawValue = (string) $oldValue->getValue();
$existingNewId = $valueMap[$rawValue] ?? null;
if($existingNewId !== null && $existingNewId !== $pair->new->getName()){
//this property value is associated with multiple new IDs - bad candidate for flattening
continue 2;
}
$valueMap[$rawValue] = $pair->new->getName();
}
if($flattenedProperty !== null){
//found multiple candidates for flattening - fallback to remappedStates
return false;
}
//we found a suitable candidate
$flattenedProperty = $removedProperty;
$flattenedPropertyMap = $valueMap;
break;
}
if($flattenedProperty === null){
//can't figure out how the new IDs are related to the old states - fallback to remappedStates
return false;
}
if($flattenedPropertyType === null){
throw new AssumptionFailedError("This should never happen at this point");
}
$result->flattenedProperties[$oldName] = buildFlattenPropertyRule($flattenedPropertyMap, $flattenedProperty, $flattenedPropertyType);
unset($removedProperties[$flattenedProperty]);
}
//finally, write the results to the schema
if(count($remappedPropertyValues) !== 0){
@ -332,60 +392,69 @@ function findCommonSuffix(array $strings) : string{
return strrev(findCommonPrefix($reversed));
}
/**
* @param string[] $valueToId
* @phpstan-param array<string, string> $valueToId
* @phpstan-param class-string<ByteTag|IntTag|StringTag> $propertyType
*/
function buildFlattenPropertyRule(array $valueToId, string $propertyName, string $propertyType) : BlockStateUpgradeSchemaFlattenInfo{
$ids = array_values($valueToId);
//TODO: this is a bit too enthusiastic. For example, when flattening the old "stone", it will see that
//"granite", "andesite", "stone" etc all have "e" as a common suffix, which works, but looks a bit daft.
//This also causes more remaps to be generated than necessary, since some of the values are already
//contained in the new ID.
$idPrefix = findCommonPrefix($ids);
$idSuffix = findCommonSuffix($ids);
if(strlen($idSuffix) < 2){
$idSuffix = "";
}
$valueMap = [];
foreach(Utils::stringifyKeys($valueToId) as $value => $newId){
$newValue = substr($newId, strlen($idPrefix), $idSuffix !== "" ? -strlen($idSuffix) : null);
if($newValue !== $value){
$valueMap[$value] = $newValue;
}
}
$allNumeric = true;
if(count($valueMap) > 0){
foreach(Utils::stringifyKeys($valueMap) as $value => $newValue){
if(!is_numeric($value)){
$allNumeric = false;
break;
}
}
if($allNumeric){
//add a dummy key to force the JSON to be an object and not a list
$valueMap["dummy"] = "map_not_list";
}
}
return new BlockStateUpgradeSchemaFlattenInfo(
$idPrefix,
$propertyName,
$idSuffix,
$valueMap,
$propertyType,
);
}
/**
* @param string[][][] $candidateFlattenedValues
* @phpstan-param array<string, array<string, array<string, string>>> $candidateFlattenedValues
* @param string[] $candidateFlattenPropertyTypes
* @phpstan-param array<string, class-string<ByteTag|IntTag|StringTag>> $candidateFlattenPropertyTypes
*
* @return BlockStateUpgradeSchemaFlattenedName[][]
* @phpstan-return array<string, array<string, BlockStateUpgradeSchemaFlattenedName>>
* @return BlockStateUpgradeSchemaFlattenInfo[][]
* @phpstan-return array<string, array<string, BlockStateUpgradeSchemaFlattenInfo>>
*/
function buildFlattenPropertyRules(array $candidateFlattenedValues, array $candidateFlattenPropertyTypes) : array{
$flattenPropertyRules = [];
foreach(Utils::stringifyKeys($candidateFlattenedValues) as $propertyName => $filters){
foreach(Utils::stringifyKeys($filters) as $filter => $valueToId){
$ids = array_values($valueToId);
//TODO: this is a bit too enthusiastic. For example, when flattening the old "stone", it will see that
//"granite", "andesite", "stone" etc all have "e" as a common suffix, which works, but looks a bit daft.
//This also causes more remaps to be generated than necessary, since some of the values are already
//contained in the new ID.
$idPrefix = findCommonPrefix($ids);
$idSuffix = findCommonSuffix($ids);
if(strlen($idSuffix) < 2){
$idSuffix = "";
}
$valueMap = [];
foreach(Utils::stringifyKeys($valueToId) as $value => $newId){
$newValue = substr($newId, strlen($idPrefix), $idSuffix !== "" ? -strlen($idSuffix) : null);
if($newValue !== $value){
$valueMap[$value] = $newValue;
}
}
$allNumeric = true;
if(count($valueMap) > 0){
foreach(Utils::stringifyKeys($valueMap) as $value => $newValue){
if(!is_numeric($value)){
$allNumeric = false;
break;
}
}
if($allNumeric){
//add a dummy key to force the JSON to be an object and not a list
$valueMap["dummy"] = "map_not_list";
}
}
$flattenPropertyRules[$propertyName][$filter] = new BlockStateUpgradeSchemaFlattenedName(
$idPrefix,
$propertyName,
$idSuffix,
$valueMap,
$candidateFlattenPropertyTypes[$propertyName],
);
$flattenPropertyRules[$propertyName][$filter] = buildFlattenPropertyRule($valueToId, $propertyName, $candidateFlattenPropertyTypes[$propertyName]);
}
}
ksort($flattenPropertyRules, SORT_STRING);
@ -642,10 +711,15 @@ function generateBlockStateUpgradeSchema(array $upgradeTable) : BlockStateUpgrad
throw new \RuntimeException("States with the same ID should be fully consistent");
}
}else{
//block mapped to multiple different new IDs; we can't guess these, so we just do a plain old remap
//even if some of the states stay under the same ID, the compression techniques used by this function
//implicitly rely on knowing the full set of old states and their new transformations
$result->remappedStates[$oldName] = processRemappedStates($blockStateMappings);
//try processing this as a regular state group first
//if a property was flattened into the ID, the remaining states will normally be consistent
//if not we fall back to remap states and state filters
if(!processStateGroup($oldName, $blockStateMappings, $result)){
//block mapped to multiple different new IDs; we can't guess these, so we just do a plain old remap
//even if some of the states stay under the same ID, the compression techniques used by this function
//implicitly rely on knowing the full set of old states and their new transformations
$result->remappedStates[$oldName] = processRemappedStates($blockStateMappings);
}
}
}