ValueMappings.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\data\bedrock\block\convert\property;
 
use pocketmine\block\Bamboo;
use pocketmine\block\utils\BellAttachmentType;
use pocketmine\block\utils\DirtType;
use pocketmine\block\utils\DripleafState;
use pocketmine\block\utils\DyeColor;
use pocketmine\block\utils\FroglightType;
use pocketmine\block\utils\HorizontalFacingOption;
use pocketmine\block\utils\LeverFacing;
use pocketmine\block\utils\MobHeadType;
use pocketmine\block\utils\MushroomBlockType;
use pocketmine\data\bedrock\block\BlockLegacyMetadata as LegacyMeta;
use pocketmine\data\bedrock\block\BlockStateStringValues as StringValues;
use pocketmine\data\bedrock\block\BlockTypeNames as Ids;
use pocketmine\math\Axis;
use pocketmine\math\Facing;
use pocketmine\utils\SingletonTrait;
 
final class ValueMappings{
    use SingletonTrait; //???
 
    public readonly EnumFromRawStateMap $dyeColor;
    public readonly EnumFromRawStateMap $dyeColorWithSilver;
    public readonly EnumFromRawStateMap $mobHeadType;
    public readonly EnumFromRawStateMap $froglightType;
    public readonly EnumFromRawStateMap $dirtType;
 
    public readonly EnumFromRawStateMap $dripleafState;
    public readonly EnumFromRawStateMap $bellAttachmentType;
    public readonly EnumFromRawStateMap $leverFacing;
 
    public readonly EnumFromRawStateMap $mushroomBlockType;
 
    public readonly EnumFromRawStateMap $cardinalDirection;
    public readonly EnumFromRawStateMap $blockFace;
    public readonly EnumFromRawStateMap $pillarAxis;
    public readonly IntFromRawStateMap $torchFacing;
    public readonly IntFromRawStateMap $portalAxis;
    public readonly IntFromRawStateMap $bambooLeafSize;
 
    public readonly EnumFromRawStateMap $horizontalFacing5Minus;
    public readonly EnumFromRawStateMap $horizontalFacingSWNE;
    public readonly EnumFromRawStateMap $horizontalFacingSWNEInverted;
    public readonly EnumFromRawStateMap $horizontalFacingCoral;
    public readonly EnumFromRawStateMap $horizontalFacingClassic;
    public readonly EnumFromRawStateMap $facing;
    public readonly EnumFromRawStateMap $facingEndRod;
    public readonly IntFromRawStateMap $coralAxis;
 
    public readonly IntFromRawStateMap $facingExceptDown;
    public readonly IntFromRawStateMap $facingExceptUp;
    public readonly IntFromRawStateMap $facingStem;
 
    public function __construct(){
        //flattened ID components - we can't generate constants for these
        $this->dyeColor = EnumFromRawStateMap::string(DyeColor::class, fn(DyeColor $case) => match ($case) {
            DyeColor::BLACK => "black",
            DyeColor::BLUE => "blue",
            DyeColor::BROWN => "brown",
            DyeColor::CYAN => "cyan",
            DyeColor::GRAY => "gray",
            DyeColor::GREEN => "green",
            DyeColor::LIGHT_BLUE => "light_blue",
            DyeColor::LIGHT_GRAY => "light_gray",
            DyeColor::LIME => "lime",
            DyeColor::MAGENTA => "magenta",
            DyeColor::ORANGE => "orange",
            DyeColor::PINK => "pink",
            DyeColor::PURPLE => "purple",
            DyeColor::RED => "red",
            DyeColor::WHITE => "white",
            DyeColor::YELLOW => "yellow"
        });
        $this->dyeColorWithSilver = EnumFromRawStateMap::string(DyeColor::class, fn(DyeColor $case) => match ($case) {
            DyeColor::LIGHT_GRAY => "silver",
            default => $this->dyeColor->valueToRaw($case)
        });
 
        $this->mobHeadType = EnumFromRawStateMap::string(MobHeadType::class, fn(MobHeadType $case) => match ($case) {
            MobHeadType::CREEPER => Ids::CREEPER_HEAD,
            MobHeadType::DRAGON => Ids::DRAGON_HEAD,
            MobHeadType::PIGLIN => Ids::PIGLIN_HEAD,
            MobHeadType::PLAYER => Ids::PLAYER_HEAD,
            MobHeadType::SKELETON => Ids::SKELETON_SKULL,
            MobHeadType::WITHER_SKELETON => Ids::WITHER_SKELETON_SKULL,
            MobHeadType::ZOMBIE => Ids::ZOMBIE_HEAD
        });
        $this->froglightType = EnumFromRawStateMap::string(FroglightType::class, fn(FroglightType $case) => match ($case) {
            FroglightType::OCHRE => Ids::OCHRE_FROGLIGHT,
            FroglightType::PEARLESCENT => Ids::PEARLESCENT_FROGLIGHT,
            FroglightType::VERDANT => Ids::VERDANT_FROGLIGHT,
        });
        $this->dirtType = EnumFromRawStateMap::string(DirtType::class, fn(DirtType $case) => match ($case) {
            DirtType::NORMAL => Ids::DIRT,
            DirtType::COARSE => Ids::COARSE_DIRT,
            DirtType::ROOTED => Ids::DIRT_WITH_ROOTS,
        });
 
        //state value mappings
        $this->dripleafState = EnumFromRawStateMap::string(DripleafState::class, fn(DripleafState $case) => match ($case) {
            DripleafState::STABLE => StringValues::BIG_DRIPLEAF_TILT_NONE,
            DripleafState::UNSTABLE => StringValues::BIG_DRIPLEAF_TILT_UNSTABLE,
            DripleafState::PARTIAL_TILT => StringValues::BIG_DRIPLEAF_TILT_PARTIAL_TILT,
            DripleafState::FULL_TILT => StringValues::BIG_DRIPLEAF_TILT_FULL_TILT
        });
        $this->bellAttachmentType = EnumFromRawStateMap::string(BellAttachmentType::class, fn(BellAttachmentType $case) => match ($case) {
            BellAttachmentType::FLOOR => StringValues::ATTACHMENT_STANDING,
            BellAttachmentType::CEILING => StringValues::ATTACHMENT_HANGING,
            BellAttachmentType::ONE_WALL => StringValues::ATTACHMENT_SIDE,
            BellAttachmentType::TWO_WALLS => StringValues::ATTACHMENT_MULTIPLE,
        });
        $this->leverFacing = EnumFromRawStateMap::string(LeverFacing::class, fn(LeverFacing $case) => match ($case) {
            LeverFacing::DOWN_AXIS_Z => StringValues::LEVER_DIRECTION_DOWN_NORTH_SOUTH,
            LeverFacing::DOWN_AXIS_X => StringValues::LEVER_DIRECTION_DOWN_EAST_WEST,
            LeverFacing::UP_AXIS_Z => StringValues::LEVER_DIRECTION_UP_NORTH_SOUTH,
            LeverFacing::UP_AXIS_X => StringValues::LEVER_DIRECTION_UP_EAST_WEST,
            LeverFacing::NORTH => StringValues::LEVER_DIRECTION_NORTH,
            LeverFacing::SOUTH => StringValues::LEVER_DIRECTION_SOUTH,
            LeverFacing::WEST => StringValues::LEVER_DIRECTION_WEST,
            LeverFacing::EAST => StringValues::LEVER_DIRECTION_EAST
        });
 
        $this->mushroomBlockType = EnumFromRawStateMap::int(
            MushroomBlockType::class,
            fn(MushroomBlockType $case) => match ($case) {
                MushroomBlockType::PORES => LegacyMeta::MUSHROOM_BLOCK_ALL_PORES,
                MushroomBlockType::CAP_NORTHWEST => LegacyMeta::MUSHROOM_BLOCK_CAP_NORTHWEST_CORNER,
                MushroomBlockType::CAP_NORTH => LegacyMeta::MUSHROOM_BLOCK_CAP_NORTH_SIDE,
                MushroomBlockType::CAP_NORTHEAST => LegacyMeta::MUSHROOM_BLOCK_CAP_NORTHEAST_CORNER,
                MushroomBlockType::CAP_WEST => LegacyMeta::MUSHROOM_BLOCK_CAP_WEST_SIDE,
                MushroomBlockType::CAP_MIDDLE => LegacyMeta::MUSHROOM_BLOCK_CAP_TOP_ONLY,
                MushroomBlockType::CAP_EAST => LegacyMeta::MUSHROOM_BLOCK_CAP_EAST_SIDE,
                MushroomBlockType::CAP_SOUTHWEST => LegacyMeta::MUSHROOM_BLOCK_CAP_SOUTHWEST_CORNER,
                MushroomBlockType::CAP_SOUTH => LegacyMeta::MUSHROOM_BLOCK_CAP_SOUTH_SIDE,
                MushroomBlockType::CAP_SOUTHEAST => LegacyMeta::MUSHROOM_BLOCK_CAP_SOUTHEAST_CORNER,
                MushroomBlockType::ALL_CAP => LegacyMeta::MUSHROOM_BLOCK_ALL_CAP,
            },
            fn(MushroomBlockType $case) => match ($case) {
                MushroomBlockType::ALL_CAP => [11, 12, 13],
                default => []
            }
        );
 
        //TODO: this can't use EnumFromRawStateMap until we have a dedicated HorizontalFacing enum
        $this->cardinalDirection = EnumFromRawStateMap::string(HorizontalFacingOption::class, fn(HorizontalFacingOption $case) => match ($case) {
            HorizontalFacingOption::NORTH => StringValues::MC_CARDINAL_DIRECTION_NORTH,
            HorizontalFacingOption::SOUTH => StringValues::MC_CARDINAL_DIRECTION_SOUTH,
            HorizontalFacingOption::WEST => StringValues::MC_CARDINAL_DIRECTION_WEST,
            HorizontalFacingOption::EAST => StringValues::MC_CARDINAL_DIRECTION_EAST,
        });
        $this->blockFace = EnumFromRawStateMap::string(Facing::class, fn(Facing $case) => match ($case) {
            Facing::DOWN => StringValues::MC_BLOCK_FACE_DOWN,
            Facing::UP => StringValues::MC_BLOCK_FACE_UP,
            Facing::NORTH => StringValues::MC_BLOCK_FACE_NORTH,
            Facing::SOUTH => StringValues::MC_BLOCK_FACE_SOUTH,
            Facing::WEST => StringValues::MC_BLOCK_FACE_WEST,
            Facing::EAST => StringValues::MC_BLOCK_FACE_EAST,
        });
        $this->pillarAxis = EnumFromRawStateMap::string(Axis::class, fn(Axis $case) => match ($case) {
            Axis::X => StringValues::PILLAR_AXIS_X,
            Axis::Y => StringValues::PILLAR_AXIS_Y,
            Axis::Z => StringValues::PILLAR_AXIS_Z
        });
        $this->torchFacing = IntFromRawStateMap::string([
            //TODO: horizontal directions are flipped (MCPE bug: https://bugs.mojang.com/browse/MCPE-152036)
            Facing::WEST->value => StringValues::TORCH_FACING_DIRECTION_EAST,
            Facing::SOUTH->value => StringValues::TORCH_FACING_DIRECTION_NORTH,
            Facing::NORTH->value => StringValues::TORCH_FACING_DIRECTION_SOUTH,
            Facing::UP->value => StringValues::TORCH_FACING_DIRECTION_TOP,
            Facing::EAST->value => StringValues::TORCH_FACING_DIRECTION_WEST,
        ], deserializeAliases: [
            Facing::UP->value => StringValues::TORCH_FACING_DIRECTION_UNKNOWN //should be illegal, but still supported
        ]);
        $this->portalAxis = IntFromRawStateMap::string([
            Axis::X->value => StringValues::PORTAL_AXIS_X,
            Axis::Z->value => StringValues::PORTAL_AXIS_Z,
        ], deserializeAliases: [
            Axis::X->value => StringValues::PORTAL_AXIS_UNKNOWN,
        ]);
        $this->bambooLeafSize = IntFromRawStateMap::string([
            Bamboo::NO_LEAVES => StringValues::BAMBOO_LEAF_SIZE_NO_LEAVES,
            Bamboo::SMALL_LEAVES => StringValues::BAMBOO_LEAF_SIZE_SMALL_LEAVES,
            Bamboo::LARGE_LEAVES => StringValues::BAMBOO_LEAF_SIZE_LARGE_LEAVES,
        ]);
 
        $this->horizontalFacing5Minus = EnumFromRawStateMap::int(HorizontalFacingOption::class, fn(HorizontalFacingOption $case) => match ($case) {
            HorizontalFacingOption::EAST => 0,
            HorizontalFacingOption::WEST => 1,
            HorizontalFacingOption::SOUTH => 2,
            HorizontalFacingOption::NORTH => 3
        });
        $this->horizontalFacingSWNE = EnumFromRawStateMap::int(HorizontalFacingOption::class, fn(HorizontalFacingOption $case) => match ($case) {
            HorizontalFacingOption::SOUTH => 0,
            HorizontalFacingOption::WEST => 1,
            HorizontalFacingOption::NORTH => 2,
            HorizontalFacingOption::EAST => 3
        });
        $this->horizontalFacingSWNEInverted = EnumFromRawStateMap::int(HorizontalFacingOption::class, fn(HorizontalFacingOption $case) => match ($case) {
            HorizontalFacingOption::NORTH => 0,
            HorizontalFacingOption::EAST => 1,
            HorizontalFacingOption::SOUTH => 2,
            HorizontalFacingOption::WEST => 3,
        });
        $this->horizontalFacingCoral = EnumFromRawStateMap::int(HorizontalFacingOption::class, fn(HorizontalFacingOption $case) => match ($case) {
            HorizontalFacingOption::WEST => 0,
            HorizontalFacingOption::EAST => 1,
            HorizontalFacingOption::NORTH => 2,
            HorizontalFacingOption::SOUTH => 3
        });
        $this->horizontalFacingClassic = EnumFromRawStateMap::int(HorizontalFacingOption::class, fn(HorizontalFacingOption $case) => match ($case) {
            HorizontalFacingOption::NORTH => 2,
            HorizontalFacingOption::SOUTH => 3,
            HorizontalFacingOption::WEST => 4,
            HorizontalFacingOption::EAST => 5
        }, aliasMapper: fn(HorizontalFacingOption $case) => $case === HorizontalFacingOption::NORTH ? [0, 1] : []); //should be illegal but still technically possible
 
        $this->facing = EnumFromRawStateMap::int(Facing::class, fn(Facing $case) => match ($case) {
            Facing::DOWN => 0,
            Facing::UP => 1,
            Facing::NORTH => 2,
            Facing::SOUTH => 3,
            Facing::WEST => 4,
            Facing::EAST => 5
        });
 
        //end rods have all the horizontal facing values opposite to classic facing
        $this->facingEndRod = EnumFromRawStateMap::int(Facing::class, fn(Facing $case) => match ($case) {
            Facing::DOWN => 0,
            Facing::UP => 1,
            Facing::SOUTH => 2,
            Facing::NORTH => 3,
            Facing::EAST => 4,
            Facing::WEST => 5,
        });
 
        //these can't be migrated to enums yet
        $horizontalFacingClassicTable = [
            Facing::NORTH->value => 2,
            Facing::SOUTH->value => 3,
            Facing::WEST->value => 4,
            Facing::EAST->value => 5
        ];
        $this->coralAxis = IntFromRawStateMap::int([
            Axis::X->value => 0,
            Axis::Z->value => 1,
        ]);
 
        //TODO: shitty copy pasta job, we can do this better but this is good enough for now
        $this->facingExceptDown = IntFromRawStateMap::int(
            [Facing::UP->value => 1] + $horizontalFacingClassicTable,
            deserializeAliases: [Facing::UP->value => 0]);
        $this->facingExceptUp = IntFromRawStateMap::int(
            [Facing::DOWN->value => 0] + $horizontalFacingClassicTable,
            deserializeAliases: [Facing::DOWN->value => 1]
        );
 
        //In PM, we use Facing::UP to indicate that the stem is not attached to a pumpkin/melon, since this makes the
        //most intuitive sense (the stem is pointing at the sky). However, Bedrock uses the DOWN state for this, which
        //is absurd, and I refuse to make our API similarly absurd.
        $this->facingStem = IntFromRawStateMap::int(
            [Facing::UP->value => 0] + $horizontalFacingClassicTable,
            deserializeAliases: [Facing::UP->value => 1]
        );
    }
}