From 015c053b031868ce0f9472a5343bc3c7d4834a5d Mon Sep 17 00:00:00 2001 From: caelunshun Date: Thu, 5 Sep 2019 19:36:07 -0600 Subject: [PATCH] Generate default state mappings for `Block` - resolves #116 Blocks can now be created from only their identifier using `Block::from_name_and_default_props()`. cc #108 --- blocks/data/1.13.2.dat | Bin 879479 -> 879479 bytes blocks/src/blocks.rs | 9028 +++++++++++++++++++++++++++++----------- blocks/src/lib.rs | 8 + generator/Cargo.toml | 2 +- generator/blocks.sh | 4 +- generator/items.sh | 2 +- generator/src/rust.rs | 104 +- 7 files changed, 6787 insertions(+), 2361 deletions(-) diff --git a/blocks/data/1.13.2.dat b/blocks/data/1.13.2.dat index 336359b22c5955b29b17e2070298777123dfab11..ecff75fd85a7340f576d58722189341a5872f135 100644 GIT binary patch literal 879479 zcmcef1$Z6D_4XZTuwjNWQ))@Z6w@{-rJORjvMt+cWJ#6eIChztnVFfHnVFfHnZJAX z`kXmDvse0meV%l6@6Nox_q+qUT3uP^oPE}LH#+;)o33~6Ev|plO*c5}yt6i)bK`T* zK4{gdRbyw2O`I|QoN@OtpSqXz$#w-=Y@ zW~boo{Z<_#PHbP8oSk0kPVK+yRB>v4Zf1IM$JEwMtjz(c`_}2Xg?-%*jJmTn7g=?z zKupeVom$-2|DaW;iF1VKjSgOQf@n0bwz#-y^UU0q^9OmXy2#+a#o4*tdk!3Yv9z#j z>X63v&~e-3%;MCctBxFeS%TX-y|6TRW7T0wXv^H>!s65>Jbn18qeZv*xvhKWW?V}b ztv4k%M;Pkn%`;Opm`AQUUQp*I&)+mZGdX+yB3M3Z)k)&);{3v{EmN$)(W_1r4K`0N zY}vuiAEN~Bv1@kw3>P?7HJIEoxn+8iDIB-z6hYWJxp4j_>GF70BAi{EoS&JV-A?f> zO>Uop7pqU`(Rl2{RVNGhzWPJ)llrwEJ6Tmfj4zZwrC0N@Q_YvE^=m(NakU-L(1(Oe^zAWrNwphop4z%F*a-%szUoqH1Kd5iG_`;eYG&$!scvzu zzI0QwvCA|y8^3H*vx&snf^ zUEk7b-G-J{>o>Nv+Hht|tBu#FwHi*fYc@3-yH-=P@oP6Vo48I>vo+UkYPR+))ogKa zhXi}x_0-+f!ras?zwey)4jJ*P50eYcm~dEZo22T z%}w{-PTkVdU597k_B|T!xkHb}d+)gFVqzLBE-g&Y&%<&Y-h+E??$p1}o;&yNv-d8m zPWQdVbM>yhyX?7J?=E{cMa3l3`0oAt?3wJ}XYb~yPcp-|^zXB0YyUobr&e9UAJBC2 zZyTl8p6#Rb+Pg#D+0$}}t_#yWJM6hf&klRfS644^vU_fBD_oYuC2FRz;hvq14foEf zZ({fD2`+uEz3ra)_O^TPskYSN+IKB1G&kL|*xYpQk}|t*jk^wZwYS}KL3`W1yH(qL zYuWX1VSC#>d)nLX-K(Ao(3*8!+^bLPJ@@X@dhdPI^Ea_bT{rjb+hfoD`u5m+|5X?F zH@9rnJYa-QdmcDKr@aq~_UmLpJ-C0LJrC*MXYWI!g0i*tun{`#dH4vO_C6x&lr6(Y zj?ih(qekeo_tC2^=})|Tg+6AaZhIa(Qn$U2QyXq~J)IhSXSWF7>>f7wZ+>cFae8rS zYIdnS5?{4y>)@@)*)82e)v?F-5TPg2hYYlZ$`eu*-F)2l_Qd6gkhdrGQkn3rJb5`H zWaTNTici*At$AuHVwy`;vhuWEDr=<*PM)WyBC-#WwZpZ~NL6(6by60sJTn!MeL^ei zo|UR-E9<2!T6y+zM9AB7)a4q#SETi<-HiEeo?FwA-H31GpH~yoJ%UyJ{AKEp!x!`w z3fA@um#IUBUes4;jm#b=(2Hw2vK#UB0IYdQKOy96owYBm>6jjY!mnvm`htoc_iQ-{XzRqDagzQ-`M>SbZkh>g9vBBRSvn+Mr>O+}~8&iHG4$q-$; z9DiL!M|TKT{Oc<+vZ~O|#2YF)+D@?E-?%&(^7p2mI>A-_&C8P^J8!Az$dse0yzZ^N zWQeY_U-!0NI+30AZ|@}&+FAb&wPWC8&Au!Bo&9t|Lu2o%3F$-)QFI&$1YL*wtM z328&YYJcxCb;#lS`U(Z>{r$_-AwwVND-^8w57u-VhivVKYC?L*g6sQ-m#ISueWb5Y zaDD&iGIhw%$CMEM#Gvo8|9C$g;_Cqz`$SDh_Xw8#Czq*14nNgbC|LHNuIV&R>WR

FC|LGiuIV%y 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%0DK_Lq^$Nfybx~viO_smUQPb8V)EGc11zq+#9 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 None, } } + pub fn from_name_and_default_props(name: &str) -> Option { + match name { + "minecraft:air" => Some(Block::Air), + "minecraft:stone" => Some(Block::Stone), + "minecraft:granite" => Some(Block::Granite), + "minecraft:polished_granite" => Some(Block::PolishedGranite), + "minecraft:diorite" => Some(Block::Diorite), + "minecraft:polished_diorite" => Some(Block::PolishedDiorite), + "minecraft:andesite" => Some(Block::Andesite), + "minecraft:polished_andesite" => Some(Block::PolishedAndesite), + "minecraft:grass_block" => { + let data = GrassBlockData::default(); + Some(Block::GrassBlock(data)) + } + "minecraft:dirt" => Some(Block::Dirt), + "minecraft:coarse_dirt" => Some(Block::CoarseDirt), + "minecraft:podzol" => { + let data = PodzolData::default(); + Some(Block::Podzol(data)) + } + "minecraft:cobblestone" => Some(Block::Cobblestone), + "minecraft:oak_planks" => Some(Block::OakPlanks), + "minecraft:spruce_planks" => Some(Block::SprucePlanks), + "minecraft:birch_planks" => Some(Block::BirchPlanks), + "minecraft:jungle_planks" => Some(Block::JunglePlanks), + "minecraft:acacia_planks" => Some(Block::AcaciaPlanks), + "minecraft:dark_oak_planks" => Some(Block::DarkOakPlanks), + "minecraft:oak_sapling" => { + let data = OakSaplingData::default(); + Some(Block::OakSapling(data)) + } + "minecraft:spruce_sapling" => { + let data = SpruceSaplingData::default(); + Some(Block::SpruceSapling(data)) + } + "minecraft:birch_sapling" => { + let data = BirchSaplingData::default(); + Some(Block::BirchSapling(data)) + } + "minecraft:jungle_sapling" => { + let data = JungleSaplingData::default(); + Some(Block::JungleSapling(data)) + } + "minecraft:acacia_sapling" => { + let data = AcaciaSaplingData::default(); + Some(Block::AcaciaSapling(data)) + } + "minecraft:dark_oak_sapling" => { + let data = DarkOakSaplingData::default(); + Some(Block::DarkOakSapling(data)) + } + "minecraft:bedrock" => Some(Block::Bedrock), + "minecraft:water" => { + let data = WaterData::default(); + Some(Block::Water(data)) + } + "minecraft:lava" => { + let data = LavaData::default(); + Some(Block::Lava(data)) + } + "minecraft:sand" => Some(Block::Sand), + "minecraft:red_sand" => Some(Block::RedSand), + "minecraft:gravel" => Some(Block::Gravel), + "minecraft:gold_ore" => Some(Block::GoldOre), + "minecraft:iron_ore" => Some(Block::IronOre), + "minecraft:coal_ore" => Some(Block::CoalOre), + "minecraft:oak_log" => { + let data = OakLogData::default(); + Some(Block::OakLog(data)) + } + "minecraft:spruce_log" => { + let data = SpruceLogData::default(); + Some(Block::SpruceLog(data)) + } + "minecraft:birch_log" => { + let data = BirchLogData::default(); + Some(Block::BirchLog(data)) + } + "minecraft:jungle_log" => { + let data = JungleLogData::default(); + Some(Block::JungleLog(data)) + } + "minecraft:acacia_log" => { + let data = AcaciaLogData::default(); + Some(Block::AcaciaLog(data)) + } + "minecraft:dark_oak_log" => { + let data = DarkOakLogData::default(); + Some(Block::DarkOakLog(data)) + } + "minecraft:stripped_spruce_log" => { + let data = StrippedSpruceLogData::default(); + Some(Block::StrippedSpruceLog(data)) + } + "minecraft:stripped_birch_log" => { + let data = StrippedBirchLogData::default(); + Some(Block::StrippedBirchLog(data)) + } + "minecraft:stripped_jungle_log" => { + let data = StrippedJungleLogData::default(); + Some(Block::StrippedJungleLog(data)) + } + "minecraft:stripped_acacia_log" => { + let data = StrippedAcaciaLogData::default(); + Some(Block::StrippedAcaciaLog(data)) + } + "minecraft:stripped_dark_oak_log" => { + let data = StrippedDarkOakLogData::default(); + Some(Block::StrippedDarkOakLog(data)) + } + "minecraft:stripped_oak_log" => { + let data = StrippedOakLogData::default(); + Some(Block::StrippedOakLog(data)) + } + "minecraft:oak_wood" => { + let data = OakWoodData::default(); + Some(Block::OakWood(data)) + } + "minecraft:spruce_wood" => { + let data = SpruceWoodData::default(); + Some(Block::SpruceWood(data)) + } + "minecraft:birch_wood" => { + let data = BirchWoodData::default(); + Some(Block::BirchWood(data)) + } + "minecraft:jungle_wood" => { + let data = JungleWoodData::default(); + Some(Block::JungleWood(data)) + } + "minecraft:acacia_wood" => { + let data = AcaciaWoodData::default(); + Some(Block::AcaciaWood(data)) + } + "minecraft:dark_oak_wood" => { + let data = DarkOakWoodData::default(); + Some(Block::DarkOakWood(data)) + } + "minecraft:stripped_oak_wood" => { + let data = StrippedOakWoodData::default(); + Some(Block::StrippedOakWood(data)) + } + "minecraft:stripped_spruce_wood" => { + let data = StrippedSpruceWoodData::default(); + Some(Block::StrippedSpruceWood(data)) + } + "minecraft:stripped_birch_wood" => { + let data = StrippedBirchWoodData::default(); + Some(Block::StrippedBirchWood(data)) + } + "minecraft:stripped_jungle_wood" => { + let data = StrippedJungleWoodData::default(); + Some(Block::StrippedJungleWood(data)) + } + "minecraft:stripped_acacia_wood" => { + let data = StrippedAcaciaWoodData::default(); + Some(Block::StrippedAcaciaWood(data)) + } + "minecraft:stripped_dark_oak_wood" => { + let data = StrippedDarkOakWoodData::default(); + Some(Block::StrippedDarkOakWood(data)) + } + "minecraft:oak_leaves" => { + let data = OakLeavesData::default(); + Some(Block::OakLeaves(data)) + } + "minecraft:spruce_leaves" => { + let data = SpruceLeavesData::default(); + Some(Block::SpruceLeaves(data)) + } + "minecraft:birch_leaves" => { + let data = BirchLeavesData::default(); + Some(Block::BirchLeaves(data)) + } + "minecraft:jungle_leaves" => { + let data = JungleLeavesData::default(); + Some(Block::JungleLeaves(data)) + } + "minecraft:acacia_leaves" => { + let data = AcaciaLeavesData::default(); + Some(Block::AcaciaLeaves(data)) + } + "minecraft:dark_oak_leaves" => { + let data = DarkOakLeavesData::default(); + Some(Block::DarkOakLeaves(data)) + } + "minecraft:sponge" => Some(Block::Sponge), + "minecraft:wet_sponge" => Some(Block::WetSponge), + "minecraft:glass" => Some(Block::Glass), + "minecraft:lapis_ore" => Some(Block::LapisOre), + "minecraft:lapis_block" => Some(Block::LapisBlock), + "minecraft:dispenser" => { + let data = DispenserData::default(); + Some(Block::Dispenser(data)) + } + "minecraft:sandstone" => Some(Block::Sandstone), + "minecraft:chiseled_sandstone" => Some(Block::ChiseledSandstone), + "minecraft:cut_sandstone" => Some(Block::CutSandstone), + "minecraft:note_block" => { + let data = NoteBlockData::default(); + Some(Block::NoteBlock(data)) + } + "minecraft:white_bed" => { + let data = WhiteBedData::default(); + Some(Block::WhiteBed(data)) + } + "minecraft:orange_bed" => { + let data = OrangeBedData::default(); + Some(Block::OrangeBed(data)) + } + "minecraft:magenta_bed" => { + let data = MagentaBedData::default(); + Some(Block::MagentaBed(data)) + } + "minecraft:light_blue_bed" => { + let data = LightBlueBedData::default(); + Some(Block::LightBlueBed(data)) + } + "minecraft:yellow_bed" => { + let data = YellowBedData::default(); + Some(Block::YellowBed(data)) + } + "minecraft:lime_bed" => { + let data = LimeBedData::default(); + Some(Block::LimeBed(data)) + } + "minecraft:pink_bed" => { + let data = PinkBedData::default(); + Some(Block::PinkBed(data)) + } + "minecraft:gray_bed" => { + let data = GrayBedData::default(); + Some(Block::GrayBed(data)) + } + "minecraft:light_gray_bed" => { + let data = LightGrayBedData::default(); + Some(Block::LightGrayBed(data)) + } + "minecraft:cyan_bed" => { + let data = CyanBedData::default(); + Some(Block::CyanBed(data)) + } + "minecraft:purple_bed" => { + let data = PurpleBedData::default(); + Some(Block::PurpleBed(data)) + } + "minecraft:blue_bed" => { + let data = BlueBedData::default(); + Some(Block::BlueBed(data)) + } + "minecraft:brown_bed" => { + let data = BrownBedData::default(); + Some(Block::BrownBed(data)) + } + "minecraft:green_bed" => { + let data = GreenBedData::default(); + Some(Block::GreenBed(data)) + } + "minecraft:red_bed" => { + let data = RedBedData::default(); + Some(Block::RedBed(data)) + } + "minecraft:black_bed" => { + let data = BlackBedData::default(); + Some(Block::BlackBed(data)) + } + "minecraft:powered_rail" => { + let data = PoweredRailData::default(); + Some(Block::PoweredRail(data)) + } + "minecraft:detector_rail" => { + let data = DetectorRailData::default(); + Some(Block::DetectorRail(data)) + } + "minecraft:sticky_piston" => { + let data = StickyPistonData::default(); + Some(Block::StickyPiston(data)) + } + "minecraft:cobweb" => Some(Block::Cobweb), + "minecraft:grass" => Some(Block::Grass), + "minecraft:fern" => Some(Block::Fern), + "minecraft:dead_bush" => Some(Block::DeadBush), + "minecraft:seagrass" => Some(Block::Seagrass), + "minecraft:tall_seagrass" => { + let data = TallSeagrassData::default(); + Some(Block::TallSeagrass(data)) + } + "minecraft:piston" => { + let data = PistonData::default(); + Some(Block::Piston(data)) + } + "minecraft:piston_head" => { + let data = PistonHeadData::default(); + Some(Block::PistonHead(data)) + } + "minecraft:white_wool" => Some(Block::WhiteWool), + "minecraft:orange_wool" => Some(Block::OrangeWool), + "minecraft:magenta_wool" => Some(Block::MagentaWool), + "minecraft:light_blue_wool" => Some(Block::LightBlueWool), + "minecraft:yellow_wool" => Some(Block::YellowWool), + "minecraft:lime_wool" => Some(Block::LimeWool), + "minecraft:pink_wool" => Some(Block::PinkWool), + "minecraft:gray_wool" => Some(Block::GrayWool), + "minecraft:light_gray_wool" => Some(Block::LightGrayWool), + "minecraft:cyan_wool" => Some(Block::CyanWool), + "minecraft:purple_wool" => Some(Block::PurpleWool), + "minecraft:blue_wool" => Some(Block::BlueWool), + "minecraft:brown_wool" => Some(Block::BrownWool), + "minecraft:green_wool" => Some(Block::GreenWool), + "minecraft:red_wool" => Some(Block::RedWool), + "minecraft:black_wool" => Some(Block::BlackWool), + "minecraft:moving_piston" => { + let data = MovingPistonData::default(); + Some(Block::MovingPiston(data)) + } + "minecraft:dandelion" => Some(Block::Dandelion), + "minecraft:poppy" => Some(Block::Poppy), + "minecraft:blue_orchid" => Some(Block::BlueOrchid), + "minecraft:allium" => Some(Block::Allium), + "minecraft:azure_bluet" => Some(Block::AzureBluet), + "minecraft:red_tulip" => Some(Block::RedTulip), + "minecraft:orange_tulip" => Some(Block::OrangeTulip), + "minecraft:white_tulip" => Some(Block::WhiteTulip), + "minecraft:pink_tulip" => Some(Block::PinkTulip), + "minecraft:oxeye_daisy" => Some(Block::OxeyeDaisy), + "minecraft:brown_mushroom" => Some(Block::BrownMushroom), + "minecraft:red_mushroom" => Some(Block::RedMushroom), + "minecraft:gold_block" => Some(Block::GoldBlock), + "minecraft:iron_block" => Some(Block::IronBlock), + "minecraft:bricks" => Some(Block::Bricks), + "minecraft:tnt" => { + let data = TntData::default(); + Some(Block::Tnt(data)) + } + "minecraft:bookshelf" => Some(Block::Bookshelf), + "minecraft:mossy_cobblestone" => Some(Block::MossyCobblestone), + "minecraft:obsidian" => Some(Block::Obsidian), + "minecraft:torch" => Some(Block::Torch), + "minecraft:wall_torch" => { + let data = WallTorchData::default(); + Some(Block::WallTorch(data)) + } + "minecraft:fire" => { + let data = FireData::default(); + Some(Block::Fire(data)) + } + "minecraft:spawner" => Some(Block::Spawner), + "minecraft:oak_stairs" => { + let data = OakStairsData::default(); + Some(Block::OakStairs(data)) + } + "minecraft:chest" => { + let data = ChestData::default(); + Some(Block::Chest(data)) + } + "minecraft:redstone_wire" => { + let data = RedstoneWireData::default(); + Some(Block::RedstoneWire(data)) + } + "minecraft:diamond_ore" => Some(Block::DiamondOre), + "minecraft:diamond_block" => Some(Block::DiamondBlock), + "minecraft:crafting_table" => Some(Block::CraftingTable), + "minecraft:wheat" => { + let data = WheatData::default(); + Some(Block::Wheat(data)) + } + "minecraft:farmland" => { + let data = FarmlandData::default(); + Some(Block::Farmland(data)) + } + "minecraft:furnace" => { + let data = FurnaceData::default(); + Some(Block::Furnace(data)) + } + "minecraft:sign" => { + let data = SignData::default(); + Some(Block::Sign(data)) + } + "minecraft:oak_door" => { + let data = OakDoorData::default(); + Some(Block::OakDoor(data)) + } + "minecraft:ladder" => { + let data = LadderData::default(); + Some(Block::Ladder(data)) + } + "minecraft:rail" => { + let data = RailData::default(); + Some(Block::Rail(data)) + } + "minecraft:cobblestone_stairs" => { + let data = CobblestoneStairsData::default(); + Some(Block::CobblestoneStairs(data)) + } + "minecraft:wall_sign" => { + let data = WallSignData::default(); + Some(Block::WallSign(data)) + } + "minecraft:lever" => { + let data = LeverData::default(); + Some(Block::Lever(data)) + } + "minecraft:stone_pressure_plate" => { + let data = StonePressurePlateData::default(); + Some(Block::StonePressurePlate(data)) + } + "minecraft:iron_door" => { + let data = IronDoorData::default(); + Some(Block::IronDoor(data)) + } + "minecraft:oak_pressure_plate" => { + let data = OakPressurePlateData::default(); + Some(Block::OakPressurePlate(data)) + } + "minecraft:spruce_pressure_plate" => { + let data = SprucePressurePlateData::default(); + Some(Block::SprucePressurePlate(data)) + } + "minecraft:birch_pressure_plate" => { + let data = BirchPressurePlateData::default(); + Some(Block::BirchPressurePlate(data)) + } + "minecraft:jungle_pressure_plate" => { + let data = JunglePressurePlateData::default(); + Some(Block::JunglePressurePlate(data)) + } + "minecraft:acacia_pressure_plate" => { + let data = AcaciaPressurePlateData::default(); + Some(Block::AcaciaPressurePlate(data)) + } + "minecraft:dark_oak_pressure_plate" => { + let data = DarkOakPressurePlateData::default(); + Some(Block::DarkOakPressurePlate(data)) + } + "minecraft:redstone_ore" => { + let data = RedstoneOreData::default(); + Some(Block::RedstoneOre(data)) + } + "minecraft:redstone_torch" => { + let data = RedstoneTorchData::default(); + Some(Block::RedstoneTorch(data)) + } + "minecraft:redstone_wall_torch" => { + let data = RedstoneWallTorchData::default(); + Some(Block::RedstoneWallTorch(data)) + } + "minecraft:stone_button" => { + let data = StoneButtonData::default(); + Some(Block::StoneButton(data)) + } + "minecraft:snow" => { + let data = SnowData::default(); + Some(Block::Snow(data)) + } + "minecraft:ice" => Some(Block::Ice), + "minecraft:snow_block" => Some(Block::SnowBlock), + "minecraft:cactus" => { + let data = CactusData::default(); + Some(Block::Cactus(data)) + } + "minecraft:clay" => Some(Block::Clay), + "minecraft:sugar_cane" => { + let data = SugarCaneData::default(); + Some(Block::SugarCane(data)) + } + "minecraft:jukebox" => { + let data = JukeboxData::default(); + Some(Block::Jukebox(data)) + } + "minecraft:oak_fence" => { + let data = OakFenceData::default(); + Some(Block::OakFence(data)) + } + "minecraft:pumpkin" => Some(Block::Pumpkin), + "minecraft:netherrack" => Some(Block::Netherrack), + "minecraft:soul_sand" => Some(Block::SoulSand), + "minecraft:glowstone" => Some(Block::Glowstone), + "minecraft:nether_portal" => { + let data = NetherPortalData::default(); + Some(Block::NetherPortal(data)) + } + "minecraft:carved_pumpkin" => { + let data = CarvedPumpkinData::default(); + Some(Block::CarvedPumpkin(data)) + } + "minecraft:jack_o_lantern" => { + let data = JackOLanternData::default(); + Some(Block::JackOLantern(data)) + } + "minecraft:cake" => { + let data = CakeData::default(); + Some(Block::Cake(data)) + } + "minecraft:repeater" => { + let data = RepeaterData::default(); + Some(Block::Repeater(data)) + } + "minecraft:white_stained_glass" => Some(Block::WhiteStainedGlass), + "minecraft:orange_stained_glass" => Some(Block::OrangeStainedGlass), + "minecraft:magenta_stained_glass" => Some(Block::MagentaStainedGlass), + "minecraft:light_blue_stained_glass" => Some(Block::LightBlueStainedGlass), + "minecraft:yellow_stained_glass" => Some(Block::YellowStainedGlass), + "minecraft:lime_stained_glass" => Some(Block::LimeStainedGlass), + "minecraft:pink_stained_glass" => Some(Block::PinkStainedGlass), + "minecraft:gray_stained_glass" => Some(Block::GrayStainedGlass), + "minecraft:light_gray_stained_glass" => Some(Block::LightGrayStainedGlass), + "minecraft:cyan_stained_glass" => Some(Block::CyanStainedGlass), + "minecraft:purple_stained_glass" => Some(Block::PurpleStainedGlass), + "minecraft:blue_stained_glass" => Some(Block::BlueStainedGlass), + "minecraft:brown_stained_glass" => Some(Block::BrownStainedGlass), + "minecraft:green_stained_glass" => Some(Block::GreenStainedGlass), + "minecraft:red_stained_glass" => Some(Block::RedStainedGlass), + "minecraft:black_stained_glass" => Some(Block::BlackStainedGlass), + "minecraft:oak_trapdoor" => { + let data = OakTrapdoorData::default(); + Some(Block::OakTrapdoor(data)) + } + "minecraft:spruce_trapdoor" => { + let data = SpruceTrapdoorData::default(); + Some(Block::SpruceTrapdoor(data)) + } + "minecraft:birch_trapdoor" => { + let data = BirchTrapdoorData::default(); + Some(Block::BirchTrapdoor(data)) + } + "minecraft:jungle_trapdoor" => { + let data = JungleTrapdoorData::default(); + Some(Block::JungleTrapdoor(data)) + } + "minecraft:acacia_trapdoor" => { + let data = AcaciaTrapdoorData::default(); + Some(Block::AcaciaTrapdoor(data)) + } + "minecraft:dark_oak_trapdoor" => { + let data = DarkOakTrapdoorData::default(); + Some(Block::DarkOakTrapdoor(data)) + } + "minecraft:infested_stone" => Some(Block::InfestedStone), + "minecraft:infested_cobblestone" => Some(Block::InfestedCobblestone), + "minecraft:infested_stone_bricks" => Some(Block::InfestedStoneBricks), + "minecraft:infested_mossy_stone_bricks" => Some(Block::InfestedMossyStoneBricks), + "minecraft:infested_cracked_stone_bricks" => Some(Block::InfestedCrackedStoneBricks), + "minecraft:infested_chiseled_stone_bricks" => Some(Block::InfestedChiseledStoneBricks), + "minecraft:stone_bricks" => Some(Block::StoneBricks), + "minecraft:mossy_stone_bricks" => Some(Block::MossyStoneBricks), + "minecraft:cracked_stone_bricks" => Some(Block::CrackedStoneBricks), + "minecraft:chiseled_stone_bricks" => Some(Block::ChiseledStoneBricks), + "minecraft:brown_mushroom_block" => { + let data = BrownMushroomBlockData::default(); + Some(Block::BrownMushroomBlock(data)) + } + "minecraft:red_mushroom_block" => { + let data = RedMushroomBlockData::default(); + Some(Block::RedMushroomBlock(data)) + } + "minecraft:mushroom_stem" => { + let data = MushroomStemData::default(); + Some(Block::MushroomStem(data)) + } + "minecraft:iron_bars" => { + let data = IronBarsData::default(); + Some(Block::IronBars(data)) + } + "minecraft:glass_pane" => { + let data = GlassPaneData::default(); + Some(Block::GlassPane(data)) + } + "minecraft:melon" => Some(Block::Melon), + "minecraft:attached_pumpkin_stem" => { + let data = AttachedPumpkinStemData::default(); + Some(Block::AttachedPumpkinStem(data)) + } + "minecraft:attached_melon_stem" => { + let data = AttachedMelonStemData::default(); + Some(Block::AttachedMelonStem(data)) + } + "minecraft:pumpkin_stem" => { + let data = PumpkinStemData::default(); + Some(Block::PumpkinStem(data)) + } + "minecraft:melon_stem" => { + let data = MelonStemData::default(); + Some(Block::MelonStem(data)) + } + "minecraft:vine" => { + let data = VineData::default(); + Some(Block::Vine(data)) + } + "minecraft:oak_fence_gate" => { + let data = OakFenceGateData::default(); + Some(Block::OakFenceGate(data)) + } + "minecraft:brick_stairs" => { + let data = BrickStairsData::default(); + Some(Block::BrickStairs(data)) + } + "minecraft:stone_brick_stairs" => { + let data = StoneBrickStairsData::default(); + Some(Block::StoneBrickStairs(data)) + } + "minecraft:mycelium" => { + let data = MyceliumData::default(); + Some(Block::Mycelium(data)) + } + "minecraft:lily_pad" => Some(Block::LilyPad), + "minecraft:nether_bricks" => Some(Block::NetherBricks), + "minecraft:nether_brick_fence" => { + let data = NetherBrickFenceData::default(); + Some(Block::NetherBrickFence(data)) + } + "minecraft:nether_brick_stairs" => { + let data = NetherBrickStairsData::default(); + Some(Block::NetherBrickStairs(data)) + } + "minecraft:nether_wart" => { + let data = NetherWartData::default(); + Some(Block::NetherWart(data)) + } + "minecraft:enchanting_table" => Some(Block::EnchantingTable), + "minecraft:brewing_stand" => { + let data = BrewingStandData::default(); + Some(Block::BrewingStand(data)) + } + "minecraft:cauldron" => { + let data = CauldronData::default(); + Some(Block::Cauldron(data)) + } + "minecraft:end_portal" => Some(Block::EndPortal), + "minecraft:end_portal_frame" => { + let data = EndPortalFrameData::default(); + Some(Block::EndPortalFrame(data)) + } + "minecraft:end_stone" => Some(Block::EndStone), + "minecraft:dragon_egg" => Some(Block::DragonEgg), + "minecraft:redstone_lamp" => { + let data = RedstoneLampData::default(); + Some(Block::RedstoneLamp(data)) + } + "minecraft:cocoa" => { + let data = CocoaData::default(); + Some(Block::Cocoa(data)) + } + "minecraft:sandstone_stairs" => { + let data = SandstoneStairsData::default(); + Some(Block::SandstoneStairs(data)) + } + "minecraft:emerald_ore" => Some(Block::EmeraldOre), + "minecraft:ender_chest" => { + let data = EnderChestData::default(); + Some(Block::EnderChest(data)) + } + "minecraft:tripwire_hook" => { + let data = TripwireHookData::default(); + Some(Block::TripwireHook(data)) + } + "minecraft:tripwire" => { + let data = TripwireData::default(); + Some(Block::Tripwire(data)) + } + "minecraft:emerald_block" => Some(Block::EmeraldBlock), + "minecraft:spruce_stairs" => { + let data = SpruceStairsData::default(); + Some(Block::SpruceStairs(data)) + } + "minecraft:birch_stairs" => { + let data = BirchStairsData::default(); + Some(Block::BirchStairs(data)) + } + "minecraft:jungle_stairs" => { + let data = JungleStairsData::default(); + Some(Block::JungleStairs(data)) + } + "minecraft:command_block" => { + let data = CommandBlockData::default(); + Some(Block::CommandBlock(data)) + } + "minecraft:beacon" => Some(Block::Beacon), + "minecraft:cobblestone_wall" => { + let data = CobblestoneWallData::default(); + Some(Block::CobblestoneWall(data)) + } + "minecraft:mossy_cobblestone_wall" => { + let data = MossyCobblestoneWallData::default(); + Some(Block::MossyCobblestoneWall(data)) + } + "minecraft:flower_pot" => Some(Block::FlowerPot), + "minecraft:potted_oak_sapling" => Some(Block::PottedOakSapling), + "minecraft:potted_spruce_sapling" => Some(Block::PottedSpruceSapling), + "minecraft:potted_birch_sapling" => Some(Block::PottedBirchSapling), + "minecraft:potted_jungle_sapling" => Some(Block::PottedJungleSapling), + "minecraft:potted_acacia_sapling" => Some(Block::PottedAcaciaSapling), + "minecraft:potted_dark_oak_sapling" => Some(Block::PottedDarkOakSapling), + "minecraft:potted_fern" => Some(Block::PottedFern), + "minecraft:potted_dandelion" => Some(Block::PottedDandelion), + "minecraft:potted_poppy" => Some(Block::PottedPoppy), + "minecraft:potted_blue_orchid" => Some(Block::PottedBlueOrchid), + "minecraft:potted_allium" => Some(Block::PottedAllium), + "minecraft:potted_azure_bluet" => Some(Block::PottedAzureBluet), + "minecraft:potted_red_tulip" => Some(Block::PottedRedTulip), + "minecraft:potted_orange_tulip" => Some(Block::PottedOrangeTulip), + "minecraft:potted_white_tulip" => Some(Block::PottedWhiteTulip), + "minecraft:potted_pink_tulip" => Some(Block::PottedPinkTulip), + "minecraft:potted_oxeye_daisy" => Some(Block::PottedOxeyeDaisy), + "minecraft:potted_red_mushroom" => Some(Block::PottedRedMushroom), + "minecraft:potted_brown_mushroom" => Some(Block::PottedBrownMushroom), + "minecraft:potted_dead_bush" => Some(Block::PottedDeadBush), + "minecraft:potted_cactus" => Some(Block::PottedCactus), + "minecraft:carrots" => { + let data = CarrotsData::default(); + Some(Block::Carrots(data)) + } + "minecraft:potatoes" => { + let data = PotatoesData::default(); + Some(Block::Potatoes(data)) + } + "minecraft:oak_button" => { + let data = OakButtonData::default(); + Some(Block::OakButton(data)) + } + "minecraft:spruce_button" => { + let data = SpruceButtonData::default(); + Some(Block::SpruceButton(data)) + } + "minecraft:birch_button" => { + let data = BirchButtonData::default(); + Some(Block::BirchButton(data)) + } + "minecraft:jungle_button" => { + let data = JungleButtonData::default(); + Some(Block::JungleButton(data)) + } + "minecraft:acacia_button" => { + let data = AcaciaButtonData::default(); + Some(Block::AcaciaButton(data)) + } + "minecraft:dark_oak_button" => { + let data = DarkOakButtonData::default(); + Some(Block::DarkOakButton(data)) + } + "minecraft:skeleton_wall_skull" => { + let data = SkeletonWallSkullData::default(); + Some(Block::SkeletonWallSkull(data)) + } + "minecraft:skeleton_skull" => { + let data = SkeletonSkullData::default(); + Some(Block::SkeletonSkull(data)) + } + "minecraft:wither_skeleton_wall_skull" => { + let data = WitherSkeletonWallSkullData::default(); + Some(Block::WitherSkeletonWallSkull(data)) + } + "minecraft:wither_skeleton_skull" => { + let data = WitherSkeletonSkullData::default(); + Some(Block::WitherSkeletonSkull(data)) + } + "minecraft:zombie_wall_head" => { + let data = ZombieWallHeadData::default(); + Some(Block::ZombieWallHead(data)) + } + "minecraft:zombie_head" => { + let data = ZombieHeadData::default(); + Some(Block::ZombieHead(data)) + } + "minecraft:player_wall_head" => { + let data = PlayerWallHeadData::default(); + Some(Block::PlayerWallHead(data)) + } + "minecraft:player_head" => { + let data = PlayerHeadData::default(); + Some(Block::PlayerHead(data)) + } + "minecraft:creeper_wall_head" => { + let data = CreeperWallHeadData::default(); + Some(Block::CreeperWallHead(data)) + } + "minecraft:creeper_head" => { + let data = CreeperHeadData::default(); + Some(Block::CreeperHead(data)) + } + "minecraft:dragon_wall_head" => { + let data = DragonWallHeadData::default(); + Some(Block::DragonWallHead(data)) + } + "minecraft:dragon_head" => { + let data = DragonHeadData::default(); + Some(Block::DragonHead(data)) + } + "minecraft:anvil" => { + let data = AnvilData::default(); + Some(Block::Anvil(data)) + } + "minecraft:chipped_anvil" => { + let data = ChippedAnvilData::default(); + Some(Block::ChippedAnvil(data)) + } + "minecraft:damaged_anvil" => { + let data = DamagedAnvilData::default(); + Some(Block::DamagedAnvil(data)) + } + "minecraft:trapped_chest" => { + let data = TrappedChestData::default(); + Some(Block::TrappedChest(data)) + } + "minecraft:light_weighted_pressure_plate" => { + let data = LightWeightedPressurePlateData::default(); + Some(Block::LightWeightedPressurePlate(data)) + } + "minecraft:heavy_weighted_pressure_plate" => { + let data = HeavyWeightedPressurePlateData::default(); + Some(Block::HeavyWeightedPressurePlate(data)) + } + "minecraft:comparator" => { + let data = ComparatorData::default(); + Some(Block::Comparator(data)) + } + "minecraft:daylight_detector" => { + let data = DaylightDetectorData::default(); + Some(Block::DaylightDetector(data)) + } + "minecraft:redstone_block" => Some(Block::RedstoneBlock), + "minecraft:nether_quartz_ore" => Some(Block::NetherQuartzOre), + "minecraft:hopper" => { + let data = HopperData::default(); + Some(Block::Hopper(data)) + } + "minecraft:quartz_block" => Some(Block::QuartzBlock), + "minecraft:chiseled_quartz_block" => Some(Block::ChiseledQuartzBlock), + "minecraft:quartz_pillar" => { + let data = QuartzPillarData::default(); + Some(Block::QuartzPillar(data)) + } + "minecraft:quartz_stairs" => { + let data = QuartzStairsData::default(); + Some(Block::QuartzStairs(data)) + } + "minecraft:activator_rail" => { + let data = ActivatorRailData::default(); + Some(Block::ActivatorRail(data)) + } + "minecraft:dropper" => { + let data = DropperData::default(); + Some(Block::Dropper(data)) + } + "minecraft:white_terracotta" => Some(Block::WhiteTerracotta), + "minecraft:orange_terracotta" => Some(Block::OrangeTerracotta), + "minecraft:magenta_terracotta" => Some(Block::MagentaTerracotta), + "minecraft:light_blue_terracotta" => Some(Block::LightBlueTerracotta), + "minecraft:yellow_terracotta" => Some(Block::YellowTerracotta), + "minecraft:lime_terracotta" => Some(Block::LimeTerracotta), + "minecraft:pink_terracotta" => Some(Block::PinkTerracotta), + "minecraft:gray_terracotta" => Some(Block::GrayTerracotta), + "minecraft:light_gray_terracotta" => Some(Block::LightGrayTerracotta), + "minecraft:cyan_terracotta" => Some(Block::CyanTerracotta), + "minecraft:purple_terracotta" => Some(Block::PurpleTerracotta), + "minecraft:blue_terracotta" => Some(Block::BlueTerracotta), + "minecraft:brown_terracotta" => Some(Block::BrownTerracotta), + "minecraft:green_terracotta" => Some(Block::GreenTerracotta), + "minecraft:red_terracotta" => Some(Block::RedTerracotta), + "minecraft:black_terracotta" => Some(Block::BlackTerracotta), + "minecraft:white_stained_glass_pane" => { + let data = WhiteStainedGlassPaneData::default(); + Some(Block::WhiteStainedGlassPane(data)) + } + "minecraft:orange_stained_glass_pane" => { + let data = OrangeStainedGlassPaneData::default(); + Some(Block::OrangeStainedGlassPane(data)) + } + "minecraft:magenta_stained_glass_pane" => { + let data = MagentaStainedGlassPaneData::default(); + Some(Block::MagentaStainedGlassPane(data)) + } + "minecraft:light_blue_stained_glass_pane" => { + let data = LightBlueStainedGlassPaneData::default(); + Some(Block::LightBlueStainedGlassPane(data)) + } + "minecraft:yellow_stained_glass_pane" => { + let data = YellowStainedGlassPaneData::default(); + Some(Block::YellowStainedGlassPane(data)) + } + "minecraft:lime_stained_glass_pane" => { + let data = LimeStainedGlassPaneData::default(); + Some(Block::LimeStainedGlassPane(data)) + } + "minecraft:pink_stained_glass_pane" => { + let data = PinkStainedGlassPaneData::default(); + Some(Block::PinkStainedGlassPane(data)) + } + "minecraft:gray_stained_glass_pane" => { + let data = GrayStainedGlassPaneData::default(); + Some(Block::GrayStainedGlassPane(data)) + } + "minecraft:light_gray_stained_glass_pane" => { + let data = LightGrayStainedGlassPaneData::default(); + Some(Block::LightGrayStainedGlassPane(data)) + } + "minecraft:cyan_stained_glass_pane" => { + let data = CyanStainedGlassPaneData::default(); + Some(Block::CyanStainedGlassPane(data)) + } + "minecraft:purple_stained_glass_pane" => { + let data = PurpleStainedGlassPaneData::default(); + Some(Block::PurpleStainedGlassPane(data)) + } + "minecraft:blue_stained_glass_pane" => { + let data = BlueStainedGlassPaneData::default(); + Some(Block::BlueStainedGlassPane(data)) + } + "minecraft:brown_stained_glass_pane" => { + let data = BrownStainedGlassPaneData::default(); + Some(Block::BrownStainedGlassPane(data)) + } + "minecraft:green_stained_glass_pane" => { + let data = GreenStainedGlassPaneData::default(); + Some(Block::GreenStainedGlassPane(data)) + } + "minecraft:red_stained_glass_pane" => { + let data = RedStainedGlassPaneData::default(); + Some(Block::RedStainedGlassPane(data)) + } + "minecraft:black_stained_glass_pane" => { + let data = BlackStainedGlassPaneData::default(); + Some(Block::BlackStainedGlassPane(data)) + } + "minecraft:acacia_stairs" => { + let data = AcaciaStairsData::default(); + Some(Block::AcaciaStairs(data)) + } + "minecraft:dark_oak_stairs" => { + let data = DarkOakStairsData::default(); + Some(Block::DarkOakStairs(data)) + } + "minecraft:slime_block" => Some(Block::SlimeBlock), + "minecraft:barrier" => Some(Block::Barrier), + "minecraft:iron_trapdoor" => { + let data = IronTrapdoorData::default(); + Some(Block::IronTrapdoor(data)) + } + "minecraft:prismarine" => Some(Block::Prismarine), + "minecraft:prismarine_bricks" => Some(Block::PrismarineBricks), + "minecraft:dark_prismarine" => Some(Block::DarkPrismarine), + "minecraft:prismarine_stairs" => { + let data = PrismarineStairsData::default(); + Some(Block::PrismarineStairs(data)) + } + "minecraft:prismarine_brick_stairs" => { + let data = PrismarineBrickStairsData::default(); + Some(Block::PrismarineBrickStairs(data)) + } + "minecraft:dark_prismarine_stairs" => { + let data = DarkPrismarineStairsData::default(); + Some(Block::DarkPrismarineStairs(data)) + } + "minecraft:prismarine_slab" => { + let data = PrismarineSlabData::default(); + Some(Block::PrismarineSlab(data)) + } + "minecraft:prismarine_brick_slab" => { + let data = PrismarineBrickSlabData::default(); + Some(Block::PrismarineBrickSlab(data)) + } + "minecraft:dark_prismarine_slab" => { + let data = DarkPrismarineSlabData::default(); + Some(Block::DarkPrismarineSlab(data)) + } + "minecraft:sea_lantern" => Some(Block::SeaLantern), + "minecraft:hay_block" => { + let data = HayBlockData::default(); + Some(Block::HayBlock(data)) + } + "minecraft:white_carpet" => Some(Block::WhiteCarpet), + "minecraft:orange_carpet" => Some(Block::OrangeCarpet), + "minecraft:magenta_carpet" => Some(Block::MagentaCarpet), + "minecraft:light_blue_carpet" => Some(Block::LightBlueCarpet), + "minecraft:yellow_carpet" => Some(Block::YellowCarpet), + "minecraft:lime_carpet" => Some(Block::LimeCarpet), + "minecraft:pink_carpet" => Some(Block::PinkCarpet), + "minecraft:gray_carpet" => Some(Block::GrayCarpet), + "minecraft:light_gray_carpet" => Some(Block::LightGrayCarpet), + "minecraft:cyan_carpet" => Some(Block::CyanCarpet), + "minecraft:purple_carpet" => Some(Block::PurpleCarpet), + "minecraft:blue_carpet" => Some(Block::BlueCarpet), + "minecraft:brown_carpet" => Some(Block::BrownCarpet), + "minecraft:green_carpet" => Some(Block::GreenCarpet), + "minecraft:red_carpet" => Some(Block::RedCarpet), + "minecraft:black_carpet" => Some(Block::BlackCarpet), + "minecraft:terracotta" => Some(Block::Terracotta), + "minecraft:coal_block" => Some(Block::CoalBlock), + "minecraft:packed_ice" => Some(Block::PackedIce), + "minecraft:sunflower" => { + let data = SunflowerData::default(); + Some(Block::Sunflower(data)) + } + "minecraft:lilac" => { + let data = LilacData::default(); + Some(Block::Lilac(data)) + } + "minecraft:rose_bush" => { + let data = RoseBushData::default(); + Some(Block::RoseBush(data)) + } + "minecraft:peony" => { + let data = PeonyData::default(); + Some(Block::Peony(data)) + } + "minecraft:tall_grass" => { + let data = TallGrassData::default(); + Some(Block::TallGrass(data)) + } + "minecraft:large_fern" => { + let data = LargeFernData::default(); + Some(Block::LargeFern(data)) + } + "minecraft:white_banner" => { + let data = WhiteBannerData::default(); + Some(Block::WhiteBanner(data)) + } + "minecraft:orange_banner" => { + let data = OrangeBannerData::default(); + Some(Block::OrangeBanner(data)) + } + "minecraft:magenta_banner" => { + let data = MagentaBannerData::default(); + Some(Block::MagentaBanner(data)) + } + "minecraft:light_blue_banner" => { + let data = LightBlueBannerData::default(); + Some(Block::LightBlueBanner(data)) + } + "minecraft:yellow_banner" => { + let data = YellowBannerData::default(); + Some(Block::YellowBanner(data)) + } + "minecraft:lime_banner" => { + let data = LimeBannerData::default(); + Some(Block::LimeBanner(data)) + } + "minecraft:pink_banner" => { + let data = PinkBannerData::default(); + Some(Block::PinkBanner(data)) + } + "minecraft:gray_banner" => { + let data = GrayBannerData::default(); + Some(Block::GrayBanner(data)) + } + "minecraft:light_gray_banner" => { + let data = LightGrayBannerData::default(); + Some(Block::LightGrayBanner(data)) + } + "minecraft:cyan_banner" => { + let data = CyanBannerData::default(); + Some(Block::CyanBanner(data)) + } + "minecraft:purple_banner" => { + let data = PurpleBannerData::default(); + Some(Block::PurpleBanner(data)) + } + "minecraft:blue_banner" => { + let data = BlueBannerData::default(); + Some(Block::BlueBanner(data)) + } + "minecraft:brown_banner" => { + let data = BrownBannerData::default(); + Some(Block::BrownBanner(data)) + } + "minecraft:green_banner" => { + let data = GreenBannerData::default(); + Some(Block::GreenBanner(data)) + } + "minecraft:red_banner" => { + let data = RedBannerData::default(); + Some(Block::RedBanner(data)) + } + "minecraft:black_banner" => { + let data = BlackBannerData::default(); + Some(Block::BlackBanner(data)) + } + "minecraft:white_wall_banner" => { + let data = WhiteWallBannerData::default(); + Some(Block::WhiteWallBanner(data)) + } + "minecraft:orange_wall_banner" => { + let data = OrangeWallBannerData::default(); + Some(Block::OrangeWallBanner(data)) + } + "minecraft:magenta_wall_banner" => { + let data = MagentaWallBannerData::default(); + Some(Block::MagentaWallBanner(data)) + } + "minecraft:light_blue_wall_banner" => { + let data = LightBlueWallBannerData::default(); + Some(Block::LightBlueWallBanner(data)) + } + "minecraft:yellow_wall_banner" => { + let data = YellowWallBannerData::default(); + Some(Block::YellowWallBanner(data)) + } + "minecraft:lime_wall_banner" => { + let data = LimeWallBannerData::default(); + Some(Block::LimeWallBanner(data)) + } + "minecraft:pink_wall_banner" => { + let data = PinkWallBannerData::default(); + Some(Block::PinkWallBanner(data)) + } + "minecraft:gray_wall_banner" => { + let data = GrayWallBannerData::default(); + Some(Block::GrayWallBanner(data)) + } + "minecraft:light_gray_wall_banner" => { + let data = LightGrayWallBannerData::default(); + Some(Block::LightGrayWallBanner(data)) + } + "minecraft:cyan_wall_banner" => { + let data = CyanWallBannerData::default(); + Some(Block::CyanWallBanner(data)) + } + "minecraft:purple_wall_banner" => { + let data = PurpleWallBannerData::default(); + Some(Block::PurpleWallBanner(data)) + } + "minecraft:blue_wall_banner" => { + let data = BlueWallBannerData::default(); + Some(Block::BlueWallBanner(data)) + } + "minecraft:brown_wall_banner" => { + let data = BrownWallBannerData::default(); + Some(Block::BrownWallBanner(data)) + } + "minecraft:green_wall_banner" => { + let data = GreenWallBannerData::default(); + Some(Block::GreenWallBanner(data)) + } + "minecraft:red_wall_banner" => { + let data = RedWallBannerData::default(); + Some(Block::RedWallBanner(data)) + } + "minecraft:black_wall_banner" => { + let data = BlackWallBannerData::default(); + Some(Block::BlackWallBanner(data)) + } + "minecraft:red_sandstone" => Some(Block::RedSandstone), + "minecraft:chiseled_red_sandstone" => Some(Block::ChiseledRedSandstone), + "minecraft:cut_red_sandstone" => Some(Block::CutRedSandstone), + "minecraft:red_sandstone_stairs" => { + let data = RedSandstoneStairsData::default(); + Some(Block::RedSandstoneStairs(data)) + } + "minecraft:oak_slab" => { + let data = OakSlabData::default(); + Some(Block::OakSlab(data)) + } + "minecraft:spruce_slab" => { + let data = SpruceSlabData::default(); + Some(Block::SpruceSlab(data)) + } + "minecraft:birch_slab" => { + let data = BirchSlabData::default(); + Some(Block::BirchSlab(data)) + } + "minecraft:jungle_slab" => { + let data = JungleSlabData::default(); + Some(Block::JungleSlab(data)) + } + "minecraft:acacia_slab" => { + let data = AcaciaSlabData::default(); + Some(Block::AcaciaSlab(data)) + } + "minecraft:dark_oak_slab" => { + let data = DarkOakSlabData::default(); + Some(Block::DarkOakSlab(data)) + } + "minecraft:stone_slab" => { + let data = StoneSlabData::default(); + Some(Block::StoneSlab(data)) + } + "minecraft:sandstone_slab" => { + let data = SandstoneSlabData::default(); + Some(Block::SandstoneSlab(data)) + } + "minecraft:petrified_oak_slab" => { + let data = PetrifiedOakSlabData::default(); + Some(Block::PetrifiedOakSlab(data)) + } + "minecraft:cobblestone_slab" => { + let data = CobblestoneSlabData::default(); + Some(Block::CobblestoneSlab(data)) + } + "minecraft:brick_slab" => { + let data = BrickSlabData::default(); + Some(Block::BrickSlab(data)) + } + "minecraft:stone_brick_slab" => { + let data = StoneBrickSlabData::default(); + Some(Block::StoneBrickSlab(data)) + } + "minecraft:nether_brick_slab" => { + let data = NetherBrickSlabData::default(); + Some(Block::NetherBrickSlab(data)) + } + "minecraft:quartz_slab" => { + let data = QuartzSlabData::default(); + Some(Block::QuartzSlab(data)) + } + "minecraft:red_sandstone_slab" => { + let data = RedSandstoneSlabData::default(); + Some(Block::RedSandstoneSlab(data)) + } + "minecraft:purpur_slab" => { + let data = PurpurSlabData::default(); + Some(Block::PurpurSlab(data)) + } + "minecraft:smooth_stone" => Some(Block::SmoothStone), + "minecraft:smooth_sandstone" => Some(Block::SmoothSandstone), + "minecraft:smooth_quartz" => Some(Block::SmoothQuartz), + "minecraft:smooth_red_sandstone" => Some(Block::SmoothRedSandstone), + "minecraft:spruce_fence_gate" => { + let data = SpruceFenceGateData::default(); + Some(Block::SpruceFenceGate(data)) + } + "minecraft:birch_fence_gate" => { + let data = BirchFenceGateData::default(); + Some(Block::BirchFenceGate(data)) + } + "minecraft:jungle_fence_gate" => { + let data = JungleFenceGateData::default(); + Some(Block::JungleFenceGate(data)) + } + "minecraft:acacia_fence_gate" => { + let data = AcaciaFenceGateData::default(); + Some(Block::AcaciaFenceGate(data)) + } + "minecraft:dark_oak_fence_gate" => { + let data = DarkOakFenceGateData::default(); + Some(Block::DarkOakFenceGate(data)) + } + "minecraft:spruce_fence" => { + let data = SpruceFenceData::default(); + Some(Block::SpruceFence(data)) + } + "minecraft:birch_fence" => { + let data = BirchFenceData::default(); + Some(Block::BirchFence(data)) + } + "minecraft:jungle_fence" => { + let data = JungleFenceData::default(); + Some(Block::JungleFence(data)) + } + "minecraft:acacia_fence" => { + let data = AcaciaFenceData::default(); + Some(Block::AcaciaFence(data)) + } + "minecraft:dark_oak_fence" => { + let data = DarkOakFenceData::default(); + Some(Block::DarkOakFence(data)) + } + "minecraft:spruce_door" => { + let data = SpruceDoorData::default(); + Some(Block::SpruceDoor(data)) + } + "minecraft:birch_door" => { + let data = BirchDoorData::default(); + Some(Block::BirchDoor(data)) + } + "minecraft:jungle_door" => { + let data = JungleDoorData::default(); + Some(Block::JungleDoor(data)) + } + "minecraft:acacia_door" => { + let data = AcaciaDoorData::default(); + Some(Block::AcaciaDoor(data)) + } + "minecraft:dark_oak_door" => { + let data = DarkOakDoorData::default(); + Some(Block::DarkOakDoor(data)) + } + "minecraft:end_rod" => { + let data = EndRodData::default(); + Some(Block::EndRod(data)) + } + "minecraft:chorus_plant" => { + let data = ChorusPlantData::default(); + Some(Block::ChorusPlant(data)) + } + "minecraft:chorus_flower" => { + let data = ChorusFlowerData::default(); + Some(Block::ChorusFlower(data)) + } + "minecraft:purpur_block" => Some(Block::PurpurBlock), + "minecraft:purpur_pillar" => { + let data = PurpurPillarData::default(); + Some(Block::PurpurPillar(data)) + } + "minecraft:purpur_stairs" => { + let data = PurpurStairsData::default(); + Some(Block::PurpurStairs(data)) + } + "minecraft:end_stone_bricks" => Some(Block::EndStoneBricks), + "minecraft:beetroots" => { + let data = BeetrootsData::default(); + Some(Block::Beetroots(data)) + } + "minecraft:grass_path" => Some(Block::GrassPath), + "minecraft:end_gateway" => Some(Block::EndGateway), + "minecraft:repeating_command_block" => { + let data = RepeatingCommandBlockData::default(); + Some(Block::RepeatingCommandBlock(data)) + } + "minecraft:chain_command_block" => { + let data = ChainCommandBlockData::default(); + Some(Block::ChainCommandBlock(data)) + } + "minecraft:frosted_ice" => { + let data = FrostedIceData::default(); + Some(Block::FrostedIce(data)) + } + "minecraft:magma_block" => Some(Block::MagmaBlock), + "minecraft:nether_wart_block" => Some(Block::NetherWartBlock), + "minecraft:red_nether_bricks" => Some(Block::RedNetherBricks), + "minecraft:bone_block" => { + let data = BoneBlockData::default(); + Some(Block::BoneBlock(data)) + } + "minecraft:structure_void" => Some(Block::StructureVoid), + "minecraft:observer" => { + let data = ObserverData::default(); + Some(Block::Observer(data)) + } + "minecraft:shulker_box" => { + let data = ShulkerBoxData::default(); + Some(Block::ShulkerBox(data)) + } + "minecraft:white_shulker_box" => { + let data = WhiteShulkerBoxData::default(); + Some(Block::WhiteShulkerBox(data)) + } + "minecraft:orange_shulker_box" => { + let data = OrangeShulkerBoxData::default(); + Some(Block::OrangeShulkerBox(data)) + } + "minecraft:magenta_shulker_box" => { + let data = MagentaShulkerBoxData::default(); + Some(Block::MagentaShulkerBox(data)) + } + "minecraft:light_blue_shulker_box" => { + let data = LightBlueShulkerBoxData::default(); + Some(Block::LightBlueShulkerBox(data)) + } + "minecraft:yellow_shulker_box" => { + let data = YellowShulkerBoxData::default(); + Some(Block::YellowShulkerBox(data)) + } + "minecraft:lime_shulker_box" => { + let data = LimeShulkerBoxData::default(); + Some(Block::LimeShulkerBox(data)) + } + "minecraft:pink_shulker_box" => { + let data = PinkShulkerBoxData::default(); + Some(Block::PinkShulkerBox(data)) + } + "minecraft:gray_shulker_box" => { + let data = GrayShulkerBoxData::default(); + Some(Block::GrayShulkerBox(data)) + } + "minecraft:light_gray_shulker_box" => { + let data = LightGrayShulkerBoxData::default(); + Some(Block::LightGrayShulkerBox(data)) + } + "minecraft:cyan_shulker_box" => { + let data = CyanShulkerBoxData::default(); + Some(Block::CyanShulkerBox(data)) + } + "minecraft:purple_shulker_box" => { + let data = PurpleShulkerBoxData::default(); + Some(Block::PurpleShulkerBox(data)) + } + "minecraft:blue_shulker_box" => { + let data = BlueShulkerBoxData::default(); + Some(Block::BlueShulkerBox(data)) + } + "minecraft:brown_shulker_box" => { + let data = BrownShulkerBoxData::default(); + Some(Block::BrownShulkerBox(data)) + } + "minecraft:green_shulker_box" => { + let data = GreenShulkerBoxData::default(); + Some(Block::GreenShulkerBox(data)) + } + "minecraft:red_shulker_box" => { + let data = RedShulkerBoxData::default(); + Some(Block::RedShulkerBox(data)) + } + "minecraft:black_shulker_box" => { + let data = BlackShulkerBoxData::default(); + Some(Block::BlackShulkerBox(data)) + } + "minecraft:white_glazed_terracotta" => { + let data = WhiteGlazedTerracottaData::default(); + Some(Block::WhiteGlazedTerracotta(data)) + } + "minecraft:orange_glazed_terracotta" => { + let data = OrangeGlazedTerracottaData::default(); + Some(Block::OrangeGlazedTerracotta(data)) + } + "minecraft:magenta_glazed_terracotta" => { + let data = MagentaGlazedTerracottaData::default(); + Some(Block::MagentaGlazedTerracotta(data)) + } + "minecraft:light_blue_glazed_terracotta" => { + let data = LightBlueGlazedTerracottaData::default(); + Some(Block::LightBlueGlazedTerracotta(data)) + } + "minecraft:yellow_glazed_terracotta" => { + let data = YellowGlazedTerracottaData::default(); + Some(Block::YellowGlazedTerracotta(data)) + } + "minecraft:lime_glazed_terracotta" => { + let data = LimeGlazedTerracottaData::default(); + Some(Block::LimeGlazedTerracotta(data)) + } + "minecraft:pink_glazed_terracotta" => { + let data = PinkGlazedTerracottaData::default(); + Some(Block::PinkGlazedTerracotta(data)) + } + "minecraft:gray_glazed_terracotta" => { + let data = GrayGlazedTerracottaData::default(); + Some(Block::GrayGlazedTerracotta(data)) + } + "minecraft:light_gray_glazed_terracotta" => { + let data = LightGrayGlazedTerracottaData::default(); + Some(Block::LightGrayGlazedTerracotta(data)) + } + "minecraft:cyan_glazed_terracotta" => { + let data = CyanGlazedTerracottaData::default(); + Some(Block::CyanGlazedTerracotta(data)) + } + "minecraft:purple_glazed_terracotta" => { + let data = PurpleGlazedTerracottaData::default(); + Some(Block::PurpleGlazedTerracotta(data)) + } + "minecraft:blue_glazed_terracotta" => { + let data = BlueGlazedTerracottaData::default(); + Some(Block::BlueGlazedTerracotta(data)) + } + "minecraft:brown_glazed_terracotta" => { + let data = BrownGlazedTerracottaData::default(); + Some(Block::BrownGlazedTerracotta(data)) + } + "minecraft:green_glazed_terracotta" => { + let data = GreenGlazedTerracottaData::default(); + Some(Block::GreenGlazedTerracotta(data)) + } + "minecraft:red_glazed_terracotta" => { + let data = RedGlazedTerracottaData::default(); + Some(Block::RedGlazedTerracotta(data)) + } + "minecraft:black_glazed_terracotta" => { + let data = BlackGlazedTerracottaData::default(); + Some(Block::BlackGlazedTerracotta(data)) + } + "minecraft:white_concrete" => Some(Block::WhiteConcrete), + "minecraft:orange_concrete" => Some(Block::OrangeConcrete), + "minecraft:magenta_concrete" => Some(Block::MagentaConcrete), + "minecraft:light_blue_concrete" => Some(Block::LightBlueConcrete), + "minecraft:yellow_concrete" => Some(Block::YellowConcrete), + "minecraft:lime_concrete" => Some(Block::LimeConcrete), + "minecraft:pink_concrete" => Some(Block::PinkConcrete), + "minecraft:gray_concrete" => Some(Block::GrayConcrete), + "minecraft:light_gray_concrete" => Some(Block::LightGrayConcrete), + "minecraft:cyan_concrete" => Some(Block::CyanConcrete), + "minecraft:purple_concrete" => Some(Block::PurpleConcrete), + "minecraft:blue_concrete" => Some(Block::BlueConcrete), + "minecraft:brown_concrete" => Some(Block::BrownConcrete), + "minecraft:green_concrete" => Some(Block::GreenConcrete), + "minecraft:red_concrete" => Some(Block::RedConcrete), + "minecraft:black_concrete" => Some(Block::BlackConcrete), + "minecraft:white_concrete_powder" => Some(Block::WhiteConcretePowder), + "minecraft:orange_concrete_powder" => Some(Block::OrangeConcretePowder), + "minecraft:magenta_concrete_powder" => Some(Block::MagentaConcretePowder), + "minecraft:light_blue_concrete_powder" => Some(Block::LightBlueConcretePowder), + "minecraft:yellow_concrete_powder" => Some(Block::YellowConcretePowder), + "minecraft:lime_concrete_powder" => Some(Block::LimeConcretePowder), + "minecraft:pink_concrete_powder" => Some(Block::PinkConcretePowder), + "minecraft:gray_concrete_powder" => Some(Block::GrayConcretePowder), + "minecraft:light_gray_concrete_powder" => Some(Block::LightGrayConcretePowder), + "minecraft:cyan_concrete_powder" => Some(Block::CyanConcretePowder), + "minecraft:purple_concrete_powder" => Some(Block::PurpleConcretePowder), + "minecraft:blue_concrete_powder" => Some(Block::BlueConcretePowder), + "minecraft:brown_concrete_powder" => Some(Block::BrownConcretePowder), + "minecraft:green_concrete_powder" => Some(Block::GreenConcretePowder), + "minecraft:red_concrete_powder" => Some(Block::RedConcretePowder), + "minecraft:black_concrete_powder" => Some(Block::BlackConcretePowder), + "minecraft:kelp" => { + let data = KelpData::default(); + Some(Block::Kelp(data)) + } + "minecraft:kelp_plant" => Some(Block::KelpPlant), + "minecraft:dried_kelp_block" => Some(Block::DriedKelpBlock), + "minecraft:turtle_egg" => { + let data = TurtleEggData::default(); + Some(Block::TurtleEgg(data)) + } + "minecraft:dead_tube_coral_block" => Some(Block::DeadTubeCoralBlock), + "minecraft:dead_brain_coral_block" => Some(Block::DeadBrainCoralBlock), + "minecraft:dead_bubble_coral_block" => Some(Block::DeadBubbleCoralBlock), + "minecraft:dead_fire_coral_block" => Some(Block::DeadFireCoralBlock), + "minecraft:dead_horn_coral_block" => Some(Block::DeadHornCoralBlock), + "minecraft:tube_coral_block" => Some(Block::TubeCoralBlock), + "minecraft:brain_coral_block" => Some(Block::BrainCoralBlock), + "minecraft:bubble_coral_block" => Some(Block::BubbleCoralBlock), + "minecraft:fire_coral_block" => Some(Block::FireCoralBlock), + "minecraft:horn_coral_block" => Some(Block::HornCoralBlock), + "minecraft:dead_tube_coral" => { + let data = DeadTubeCoralData::default(); + Some(Block::DeadTubeCoral(data)) + } + "minecraft:dead_brain_coral" => { + let data = DeadBrainCoralData::default(); + Some(Block::DeadBrainCoral(data)) + } + "minecraft:dead_bubble_coral" => { + let data = DeadBubbleCoralData::default(); + Some(Block::DeadBubbleCoral(data)) + } + "minecraft:dead_fire_coral" => { + let data = DeadFireCoralData::default(); + Some(Block::DeadFireCoral(data)) + } + "minecraft:dead_horn_coral" => { + let data = DeadHornCoralData::default(); + Some(Block::DeadHornCoral(data)) + } + "minecraft:tube_coral" => { + let data = TubeCoralData::default(); + Some(Block::TubeCoral(data)) + } + "minecraft:brain_coral" => { + let data = BrainCoralData::default(); + Some(Block::BrainCoral(data)) + } + "minecraft:bubble_coral" => { + let data = BubbleCoralData::default(); + Some(Block::BubbleCoral(data)) + } + "minecraft:fire_coral" => { + let data = FireCoralData::default(); + Some(Block::FireCoral(data)) + } + "minecraft:horn_coral" => { + let data = HornCoralData::default(); + Some(Block::HornCoral(data)) + } + "minecraft:dead_tube_coral_wall_fan" => { + let data = DeadTubeCoralWallFanData::default(); + Some(Block::DeadTubeCoralWallFan(data)) + } + "minecraft:dead_brain_coral_wall_fan" => { + let data = DeadBrainCoralWallFanData::default(); + Some(Block::DeadBrainCoralWallFan(data)) + } + "minecraft:dead_bubble_coral_wall_fan" => { + let data = DeadBubbleCoralWallFanData::default(); + Some(Block::DeadBubbleCoralWallFan(data)) + } + "minecraft:dead_fire_coral_wall_fan" => { + let data = DeadFireCoralWallFanData::default(); + Some(Block::DeadFireCoralWallFan(data)) + } + "minecraft:dead_horn_coral_wall_fan" => { + let data = DeadHornCoralWallFanData::default(); + Some(Block::DeadHornCoralWallFan(data)) + } + "minecraft:tube_coral_wall_fan" => { + let data = TubeCoralWallFanData::default(); + Some(Block::TubeCoralWallFan(data)) + } + "minecraft:brain_coral_wall_fan" => { + let data = BrainCoralWallFanData::default(); + Some(Block::BrainCoralWallFan(data)) + } + "minecraft:bubble_coral_wall_fan" => { + let data = BubbleCoralWallFanData::default(); + Some(Block::BubbleCoralWallFan(data)) + } + "minecraft:fire_coral_wall_fan" => { + let data = FireCoralWallFanData::default(); + Some(Block::FireCoralWallFan(data)) + } + "minecraft:horn_coral_wall_fan" => { + let data = HornCoralWallFanData::default(); + Some(Block::HornCoralWallFan(data)) + } + "minecraft:dead_tube_coral_fan" => { + let data = DeadTubeCoralFanData::default(); + Some(Block::DeadTubeCoralFan(data)) + } + "minecraft:dead_brain_coral_fan" => { + let data = DeadBrainCoralFanData::default(); + Some(Block::DeadBrainCoralFan(data)) + } + "minecraft:dead_bubble_coral_fan" => { + let data = DeadBubbleCoralFanData::default(); + Some(Block::DeadBubbleCoralFan(data)) + } + "minecraft:dead_fire_coral_fan" => { + let data = DeadFireCoralFanData::default(); + Some(Block::DeadFireCoralFan(data)) + } + "minecraft:dead_horn_coral_fan" => { + let data = DeadHornCoralFanData::default(); + Some(Block::DeadHornCoralFan(data)) + } + "minecraft:tube_coral_fan" => { + let data = TubeCoralFanData::default(); + Some(Block::TubeCoralFan(data)) + } + "minecraft:brain_coral_fan" => { + let data = BrainCoralFanData::default(); + Some(Block::BrainCoralFan(data)) + } + "minecraft:bubble_coral_fan" => { + let data = BubbleCoralFanData::default(); + Some(Block::BubbleCoralFan(data)) + } + "minecraft:fire_coral_fan" => { + let data = FireCoralFanData::default(); + Some(Block::FireCoralFan(data)) + } + "minecraft:horn_coral_fan" => { + let data = HornCoralFanData::default(); + Some(Block::HornCoralFan(data)) + } + "minecraft:sea_pickle" => { + let data = SeaPickleData::default(); + Some(Block::SeaPickle(data)) + } + "minecraft:blue_ice" => Some(Block::BlueIce), + "minecraft:conduit" => { + let data = ConduitData::default(); + Some(Block::Conduit(data)) + } + "minecraft:void_air" => Some(Block::VoidAir), + "minecraft:cave_air" => Some(Block::CaveAir), + "minecraft:bubble_column" => { + let data = BubbleColumnData::default(); + Some(Block::BubbleColumn(data)) + } + "minecraft:structure_block" => { + let data = StructureBlockData::default(); + Some(Block::StructureBlock(data)) + } + _ => None, + } + } pub fn from_internal_state_id(id: usize) -> Option { match id { 0usize => Some(Block::Air), @@ -5626,6 +7279,11 @@ impl GrassBlockData { m } } +impl Default for GrassBlockData { + fn default() -> Self { + Self { snowy: false } + } +} impl Value for GrassBlockData { fn value(&self) -> usize { (self.snowy.value() * 1usize) @@ -5656,6 +7314,11 @@ impl PodzolData { m } } +impl Default for PodzolData { + fn default() -> Self { + Self { snowy: false } + } +} impl Value for PodzolData { fn value(&self) -> usize { (self.snowy.value() * 1usize) @@ -5686,6 +7349,11 @@ impl OakSaplingData { m } } +impl Default for OakSaplingData { + fn default() -> Self { + Self { stage: 0 } + } +} impl Value for OakSaplingData { fn value(&self) -> usize { (self.stage.value() * 1usize) @@ -5716,6 +7384,11 @@ impl SpruceSaplingData { m } } +impl Default for SpruceSaplingData { + fn default() -> Self { + Self { stage: 0 } + } +} impl Value for SpruceSaplingData { fn value(&self) -> usize { (self.stage.value() * 1usize) @@ -5746,6 +7419,11 @@ impl BirchSaplingData { m } } +impl Default for BirchSaplingData { + fn default() -> Self { + Self { stage: 0 } + } +} impl Value for BirchSaplingData { fn value(&self) -> usize { (self.stage.value() * 1usize) @@ -5776,6 +7454,11 @@ impl JungleSaplingData { m } } +impl Default for JungleSaplingData { + fn default() -> Self { + Self { stage: 0 } + } +} impl Value for JungleSaplingData { fn value(&self) -> usize { (self.stage.value() * 1usize) @@ -5806,6 +7489,11 @@ impl AcaciaSaplingData { m } } +impl Default for AcaciaSaplingData { + fn default() -> Self { + Self { stage: 0 } + } +} impl Value for AcaciaSaplingData { fn value(&self) -> usize { (self.stage.value() * 1usize) @@ -5836,6 +7524,11 @@ impl DarkOakSaplingData { m } } +impl Default for DarkOakSaplingData { + fn default() -> Self { + Self { stage: 0 } + } +} impl Value for DarkOakSaplingData { fn value(&self) -> usize { (self.stage.value() * 1usize) @@ -5866,6 +7559,11 @@ impl WaterData { m } } +impl Default for WaterData { + fn default() -> Self { + Self { level: 0 } + } +} impl Value for WaterData { fn value(&self) -> usize { (self.level.value() * 1usize) @@ -5896,6 +7594,11 @@ impl LavaData { m } } +impl Default for LavaData { + fn default() -> Self { + Self { level: 0 } + } +} impl Value for LavaData { fn value(&self) -> usize { (self.level.value() * 1usize) @@ -5926,6 +7629,13 @@ impl OakLogData { m } } +impl Default for OakLogData { + fn default() -> Self { + Self { + axis: OakLogAxis::Y, + } + } +} impl Value for OakLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -5956,6 +7666,13 @@ impl SpruceLogData { m } } +impl Default for SpruceLogData { + fn default() -> Self { + Self { + axis: SpruceLogAxis::Y, + } + } +} impl Value for SpruceLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -5986,6 +7703,13 @@ impl BirchLogData { m } } +impl Default for BirchLogData { + fn default() -> Self { + Self { + axis: BirchLogAxis::Y, + } + } +} impl Value for BirchLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6016,6 +7740,13 @@ impl JungleLogData { m } } +impl Default for JungleLogData { + fn default() -> Self { + Self { + axis: JungleLogAxis::Y, + } + } +} impl Value for JungleLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6046,6 +7777,13 @@ impl AcaciaLogData { m } } +impl Default for AcaciaLogData { + fn default() -> Self { + Self { + axis: AcaciaLogAxis::Y, + } + } +} impl Value for AcaciaLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6076,6 +7814,13 @@ impl DarkOakLogData { m } } +impl Default for DarkOakLogData { + fn default() -> Self { + Self { + axis: DarkOakLogAxis::Y, + } + } +} impl Value for DarkOakLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6106,6 +7851,13 @@ impl StrippedSpruceLogData { m } } +impl Default for StrippedSpruceLogData { + fn default() -> Self { + Self { + axis: StrippedSpruceLogAxis::Y, + } + } +} impl Value for StrippedSpruceLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6136,6 +7888,13 @@ impl StrippedBirchLogData { m } } +impl Default for StrippedBirchLogData { + fn default() -> Self { + Self { + axis: StrippedBirchLogAxis::Y, + } + } +} impl Value for StrippedBirchLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6166,6 +7925,13 @@ impl StrippedJungleLogData { m } } +impl Default for StrippedJungleLogData { + fn default() -> Self { + Self { + axis: StrippedJungleLogAxis::Y, + } + } +} impl Value for StrippedJungleLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6196,6 +7962,13 @@ impl StrippedAcaciaLogData { m } } +impl Default for StrippedAcaciaLogData { + fn default() -> Self { + Self { + axis: StrippedAcaciaLogAxis::Y, + } + } +} impl Value for StrippedAcaciaLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6226,6 +7999,13 @@ impl StrippedDarkOakLogData { m } } +impl Default for StrippedDarkOakLogData { + fn default() -> Self { + Self { + axis: StrippedDarkOakLogAxis::Y, + } + } +} impl Value for StrippedDarkOakLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6256,6 +8036,13 @@ impl StrippedOakLogData { m } } +impl Default for StrippedOakLogData { + fn default() -> Self { + Self { + axis: StrippedOakLogAxis::Y, + } + } +} impl Value for StrippedOakLogData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6286,6 +8073,13 @@ impl OakWoodData { m } } +impl Default for OakWoodData { + fn default() -> Self { + Self { + axis: OakWoodAxis::Y, + } + } +} impl Value for OakWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6316,6 +8110,13 @@ impl SpruceWoodData { m } } +impl Default for SpruceWoodData { + fn default() -> Self { + Self { + axis: SpruceWoodAxis::Y, + } + } +} impl Value for SpruceWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6346,6 +8147,13 @@ impl BirchWoodData { m } } +impl Default for BirchWoodData { + fn default() -> Self { + Self { + axis: BirchWoodAxis::Y, + } + } +} impl Value for BirchWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6376,6 +8184,13 @@ impl JungleWoodData { m } } +impl Default for JungleWoodData { + fn default() -> Self { + Self { + axis: JungleWoodAxis::Y, + } + } +} impl Value for JungleWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6406,6 +8221,13 @@ impl AcaciaWoodData { m } } +impl Default for AcaciaWoodData { + fn default() -> Self { + Self { + axis: AcaciaWoodAxis::Y, + } + } +} impl Value for AcaciaWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6436,6 +8258,13 @@ impl DarkOakWoodData { m } } +impl Default for DarkOakWoodData { + fn default() -> Self { + Self { + axis: DarkOakWoodAxis::Y, + } + } +} impl Value for DarkOakWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6466,6 +8295,13 @@ impl StrippedOakWoodData { m } } +impl Default for StrippedOakWoodData { + fn default() -> Self { + Self { + axis: StrippedOakWoodAxis::Y, + } + } +} impl Value for StrippedOakWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6496,6 +8332,13 @@ impl StrippedSpruceWoodData { m } } +impl Default for StrippedSpruceWoodData { + fn default() -> Self { + Self { + axis: StrippedSpruceWoodAxis::Y, + } + } +} impl Value for StrippedSpruceWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6526,6 +8369,13 @@ impl StrippedBirchWoodData { m } } +impl Default for StrippedBirchWoodData { + fn default() -> Self { + Self { + axis: StrippedBirchWoodAxis::Y, + } + } +} impl Value for StrippedBirchWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6556,6 +8406,13 @@ impl StrippedJungleWoodData { m } } +impl Default for StrippedJungleWoodData { + fn default() -> Self { + Self { + axis: StrippedJungleWoodAxis::Y, + } + } +} impl Value for StrippedJungleWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6586,6 +8443,13 @@ impl StrippedAcaciaWoodData { m } } +impl Default for StrippedAcaciaWoodData { + fn default() -> Self { + Self { + axis: StrippedAcaciaWoodAxis::Y, + } + } +} impl Value for StrippedAcaciaWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6616,6 +8480,13 @@ impl StrippedDarkOakWoodData { m } } +impl Default for StrippedDarkOakWoodData { + fn default() -> Self { + Self { + axis: StrippedDarkOakWoodAxis::Y, + } + } +} impl Value for StrippedDarkOakWoodData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -6649,6 +8520,14 @@ impl OakLeavesData { m } } +impl Default for OakLeavesData { + fn default() -> Self { + Self { + persistent: false, + distance: 7, + } + } +} impl Value for OakLeavesData { fn value(&self) -> usize { (self.persistent.value() * 7usize) + ((self.distance.value() - 1) * 1usize) @@ -6670,77 +8549,93 @@ impl Value for OakLeavesData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct SpruceLeavesData { - pub distance: i32, pub persistent: bool, + pub distance: i32, } impl SpruceLeavesData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - distance: i32::from_snake_case(map.get("distance")?)?, persistent: bool::from_snake_case(map.get("persistent")?)?, + distance: i32::from_snake_case(map.get("distance")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("distance".to_string(), self.distance.to_snake_case()); m.insert("persistent".to_string(), self.persistent.to_snake_case()); + m.insert("distance".to_string(), self.distance.to_snake_case()); m } } +impl Default for SpruceLeavesData { + fn default() -> Self { + Self { + persistent: false, + distance: 7, + } + } +} impl Value for SpruceLeavesData { fn value(&self) -> usize { - ((self.distance.value() - 1) * 2usize) + (self.persistent.value() * 1usize) + (self.persistent.value() * 7usize) + ((self.distance.value() - 1) * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 14usize { return None; } - let distance = i32::from_value(val / 2usize).unwrap() + 1i32; - val -= (distance.value() - 1usize) * 2usize; - let persistent = bool::from_value(val / 1usize).unwrap(); - val -= (persistent.value() - 0usize) * 1usize; + let persistent = bool::from_value(val / 7usize).unwrap(); + val -= (persistent.value() - 0usize) * 7usize; + let distance = i32::from_value(val / 1usize).unwrap() + 1i32; + val -= (distance.value() - 1usize) * 1usize; Some(Self { - distance, persistent, + distance, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BirchLeavesData { - pub persistent: bool, pub distance: i32, + pub persistent: bool, } impl BirchLeavesData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - persistent: bool::from_snake_case(map.get("persistent")?)?, distance: i32::from_snake_case(map.get("distance")?)?, + persistent: bool::from_snake_case(map.get("persistent")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("persistent".to_string(), self.persistent.to_snake_case()); m.insert("distance".to_string(), self.distance.to_snake_case()); + m.insert("persistent".to_string(), self.persistent.to_snake_case()); m } } +impl Default for BirchLeavesData { + fn default() -> Self { + Self { + distance: 7, + persistent: false, + } + } +} impl Value for BirchLeavesData { fn value(&self) -> usize { - (self.persistent.value() * 7usize) + ((self.distance.value() - 1) * 1usize) + ((self.distance.value() - 1) * 2usize) + (self.persistent.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 14usize { return None; } - let persistent = bool::from_value(val / 7usize).unwrap(); - val -= (persistent.value() - 0usize) * 7usize; - let distance = i32::from_value(val / 1usize).unwrap() + 1i32; - val -= (distance.value() - 1usize) * 1usize; + let distance = i32::from_value(val / 2usize).unwrap() + 1i32; + val -= (distance.value() - 1usize) * 2usize; + let persistent = bool::from_value(val / 1usize).unwrap(); + val -= (persistent.value() - 0usize) * 1usize; Some(Self { - persistent, distance, + persistent, }) } } @@ -6763,6 +8658,14 @@ impl JungleLeavesData { m } } +impl Default for JungleLeavesData { + fn default() -> Self { + Self { + distance: 7, + persistent: false, + } + } +} impl Value for JungleLeavesData { fn value(&self) -> usize { ((self.distance.value() - 1) * 2usize) + (self.persistent.value() * 1usize) @@ -6801,6 +8704,14 @@ impl AcaciaLeavesData { m } } +impl Default for AcaciaLeavesData { + fn default() -> Self { + Self { + persistent: false, + distance: 7, + } + } +} impl Value for AcaciaLeavesData { fn value(&self) -> usize { (self.persistent.value() * 7usize) + ((self.distance.value() - 1) * 1usize) @@ -6839,6 +8750,14 @@ impl DarkOakLeavesData { m } } +impl Default for DarkOakLeavesData { + fn default() -> Self { + Self { + distance: 7, + persistent: false, + } + } +} impl Value for DarkOakLeavesData { fn value(&self) -> usize { ((self.distance.value() - 1) * 2usize) + (self.persistent.value() * 1usize) @@ -6860,66 +8779,83 @@ impl Value for DarkOakLeavesData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DispenserData { - pub triggered: bool, pub facing: DispenserFacing, + pub triggered: bool, } impl DispenserData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - triggered: bool::from_snake_case(map.get("triggered")?)?, facing: DispenserFacing::from_snake_case(map.get("facing")?)?, + triggered: bool::from_snake_case(map.get("triggered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("triggered".to_string(), self.triggered.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("triggered".to_string(), self.triggered.to_snake_case()); m } } +impl Default for DispenserData { + fn default() -> Self { + Self { + facing: DispenserFacing::North, + triggered: false, + } + } +} impl Value for DispenserData { fn value(&self) -> usize { - (self.triggered.value() * 6usize) + (self.facing.value() * 1usize) + (self.facing.value() * 2usize) + (self.triggered.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 12usize { return None; } - let triggered = bool::from_value(val / 6usize).unwrap(); - val -= (triggered.value() - 0usize) * 6usize; - let facing = DispenserFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; - Some(Self { triggered, facing }) + let facing = DispenserFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let triggered = bool::from_value(val / 1usize).unwrap(); + val -= (triggered.value() - 0usize) * 1usize; + Some(Self { facing, triggered }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct NoteBlockData { pub instrument: NoteBlockInstrument, - pub powered: bool, pub note: i32, + pub powered: bool, } impl NoteBlockData { pub fn from_map(map: &HashMap) -> Option { Some(Self { instrument: NoteBlockInstrument::from_snake_case(map.get("instrument")?)?, - powered: bool::from_snake_case(map.get("powered")?)?, note: i32::from_snake_case(map.get("note")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("instrument".to_string(), self.instrument.to_snake_case()); - m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("note".to_string(), self.note.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for NoteBlockData { + fn default() -> Self { + Self { + instrument: NoteBlockInstrument::Harp, + note: 0, + powered: false, + } + } +} impl Value for NoteBlockData { fn value(&self) -> usize { (self.instrument.value() * 50usize) - + (self.powered.value() * 25usize) - + (self.note.value() * 1usize) + + (self.note.value() * 2usize) + + (self.powered.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -6928,43 +8864,52 @@ impl Value for NoteBlockData { } let instrument = NoteBlockInstrument::from_value(val / 50usize).unwrap(); val -= (instrument.value() - 0usize) * 50usize; - let powered = bool::from_value(val / 25usize).unwrap(); - val -= (powered.value() - 0usize) * 25usize; - let note = i32::from_value(val / 1usize).unwrap(); - val -= (note.value() - 0usize) * 1usize; + let note = i32::from_value(val / 2usize).unwrap(); + val -= (note.value() - 0usize) * 2usize; + let powered = bool::from_value(val / 1usize).unwrap(); + val -= (powered.value() - 0usize) * 1usize; Some(Self { instrument, - powered, note, + powered, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct WhiteBedData { - pub part: WhiteBedPart, pub occupied: bool, + pub part: WhiteBedPart, pub facing: WhiteBedFacing, } impl WhiteBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - part: WhiteBedPart::from_snake_case(map.get("part")?)?, occupied: bool::from_snake_case(map.get("occupied")?)?, + part: WhiteBedPart::from_snake_case(map.get("part")?)?, facing: WhiteBedFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("part".to_string(), self.part.to_snake_case()); m.insert("occupied".to_string(), self.occupied.to_snake_case()); + m.insert("part".to_string(), self.part.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for WhiteBedData { + fn default() -> Self { + Self { + occupied: false, + part: WhiteBedPart::Foot, + facing: WhiteBedFacing::North, + } + } +} impl Value for WhiteBedData { fn value(&self) -> usize { - (self.part.value() * 8usize) - + (self.occupied.value() * 4usize) + (self.occupied.value() * 8usize) + + (self.part.value() * 4usize) + (self.facing.value() * 1usize) } #[allow(warnings)] @@ -6972,15 +8917,15 @@ impl Value for WhiteBedData { if val >= 16usize { return None; } - let part = WhiteBedPart::from_value(val / 8usize).unwrap(); - val -= (part.value() - 0usize) * 8usize; - let occupied = bool::from_value(val / 4usize).unwrap(); - val -= (occupied.value() - 0usize) * 4usize; + let occupied = bool::from_value(val / 8usize).unwrap(); + val -= (occupied.value() - 0usize) * 8usize; + let part = WhiteBedPart::from_value(val / 4usize).unwrap(); + val -= (part.value() - 0usize) * 4usize; let facing = WhiteBedFacing::from_value(val / 1usize).unwrap(); val -= (facing.value() - 0usize) * 1usize; Some(Self { - part, occupied, + part, facing, }) } @@ -6988,30 +8933,39 @@ impl Value for WhiteBedData { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct OrangeBedData { pub facing: OrangeBedFacing, - pub part: OrangeBedPart, pub occupied: bool, + pub part: OrangeBedPart, } impl OrangeBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { facing: OrangeBedFacing::from_snake_case(map.get("facing")?)?, - part: OrangeBedPart::from_snake_case(map.get("part")?)?, occupied: bool::from_snake_case(map.get("occupied")?)?, + part: OrangeBedPart::from_snake_case(map.get("part")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("part".to_string(), self.part.to_snake_case()); m.insert("occupied".to_string(), self.occupied.to_snake_case()); + m.insert("part".to_string(), self.part.to_snake_case()); m } } +impl Default for OrangeBedData { + fn default() -> Self { + Self { + facing: OrangeBedFacing::North, + occupied: false, + part: OrangeBedPart::Foot, + } + } +} impl Value for OrangeBedData { fn value(&self) -> usize { (self.facing.value() * 4usize) - + (self.part.value() * 2usize) - + (self.occupied.value() * 1usize) + + (self.occupied.value() * 2usize) + + (self.part.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -7020,152 +8974,179 @@ impl Value for OrangeBedData { } let facing = OrangeBedFacing::from_value(val / 4usize).unwrap(); val -= (facing.value() - 0usize) * 4usize; - let part = OrangeBedPart::from_value(val / 2usize).unwrap(); - val -= (part.value() - 0usize) * 2usize; - let occupied = bool::from_value(val / 1usize).unwrap(); - val -= (occupied.value() - 0usize) * 1usize; + let occupied = bool::from_value(val / 2usize).unwrap(); + val -= (occupied.value() - 0usize) * 2usize; + let part = OrangeBedPart::from_value(val / 1usize).unwrap(); + val -= (part.value() - 0usize) * 1usize; Some(Self { facing, - part, occupied, + part, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct MagentaBedData { - pub part: MagentaBedPart, - pub facing: MagentaBedFacing, pub occupied: bool, + pub facing: MagentaBedFacing, + pub part: MagentaBedPart, } impl MagentaBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - part: MagentaBedPart::from_snake_case(map.get("part")?)?, - facing: MagentaBedFacing::from_snake_case(map.get("facing")?)?, occupied: bool::from_snake_case(map.get("occupied")?)?, + facing: MagentaBedFacing::from_snake_case(map.get("facing")?)?, + part: MagentaBedPart::from_snake_case(map.get("part")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("part".to_string(), self.part.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("occupied".to_string(), self.occupied.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("part".to_string(), self.part.to_snake_case()); m } } +impl Default for MagentaBedData { + fn default() -> Self { + Self { + occupied: false, + facing: MagentaBedFacing::North, + part: MagentaBedPart::Foot, + } + } +} impl Value for MagentaBedData { fn value(&self) -> usize { - (self.part.value() * 8usize) + (self.occupied.value() * 8usize) + (self.facing.value() * 2usize) - + (self.occupied.value() * 1usize) + + (self.part.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 16usize { return None; } - let part = MagentaBedPart::from_value(val / 8usize).unwrap(); - val -= (part.value() - 0usize) * 8usize; + let occupied = bool::from_value(val / 8usize).unwrap(); + val -= (occupied.value() - 0usize) * 8usize; let facing = MagentaBedFacing::from_value(val / 2usize).unwrap(); val -= (facing.value() - 0usize) * 2usize; - let occupied = bool::from_value(val / 1usize).unwrap(); - val -= (occupied.value() - 0usize) * 1usize; + let part = MagentaBedPart::from_value(val / 1usize).unwrap(); + val -= (part.value() - 0usize) * 1usize; Some(Self { - part, - facing, occupied, + facing, + part, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct LightBlueBedData { - pub facing: LightBlueBedFacing, pub occupied: bool, pub part: LightBlueBedPart, + pub facing: LightBlueBedFacing, } impl LightBlueBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: LightBlueBedFacing::from_snake_case(map.get("facing")?)?, occupied: bool::from_snake_case(map.get("occupied")?)?, part: LightBlueBedPart::from_snake_case(map.get("part")?)?, + facing: LightBlueBedFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("occupied".to_string(), self.occupied.to_snake_case()); m.insert("part".to_string(), self.part.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for LightBlueBedData { + fn default() -> Self { + Self { + occupied: false, + part: LightBlueBedPart::Foot, + facing: LightBlueBedFacing::North, + } + } +} impl Value for LightBlueBedData { fn value(&self) -> usize { - (self.facing.value() * 4usize) - + (self.occupied.value() * 2usize) - + (self.part.value() * 1usize) + (self.occupied.value() * 8usize) + + (self.part.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 16usize { return None; } - let facing = LightBlueBedFacing::from_value(val / 4usize).unwrap(); - val -= (facing.value() - 0usize) * 4usize; - let occupied = bool::from_value(val / 2usize).unwrap(); - val -= (occupied.value() - 0usize) * 2usize; - let part = LightBlueBedPart::from_value(val / 1usize).unwrap(); - val -= (part.value() - 0usize) * 1usize; + let occupied = bool::from_value(val / 8usize).unwrap(); + val -= (occupied.value() - 0usize) * 8usize; + let part = LightBlueBedPart::from_value(val / 4usize).unwrap(); + val -= (part.value() - 0usize) * 4usize; + let facing = LightBlueBedFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { - facing, occupied, part, + facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct YellowBedData { - pub facing: YellowBedFacing, - pub occupied: bool, pub part: YellowBedPart, + pub occupied: bool, + pub facing: YellowBedFacing, } impl YellowBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: YellowBedFacing::from_snake_case(map.get("facing")?)?, - occupied: bool::from_snake_case(map.get("occupied")?)?, part: YellowBedPart::from_snake_case(map.get("part")?)?, + occupied: bool::from_snake_case(map.get("occupied")?)?, + facing: YellowBedFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("occupied".to_string(), self.occupied.to_snake_case()); m.insert("part".to_string(), self.part.to_snake_case()); + m.insert("occupied".to_string(), self.occupied.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for YellowBedData { + fn default() -> Self { + Self { + part: YellowBedPart::Foot, + occupied: false, + facing: YellowBedFacing::North, + } + } +} impl Value for YellowBedData { fn value(&self) -> usize { - (self.facing.value() * 4usize) - + (self.occupied.value() * 2usize) - + (self.part.value() * 1usize) + (self.part.value() * 8usize) + + (self.occupied.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 16usize { return None; } - let facing = YellowBedFacing::from_value(val / 4usize).unwrap(); - val -= (facing.value() - 0usize) * 4usize; - let occupied = bool::from_value(val / 2usize).unwrap(); - val -= (occupied.value() - 0usize) * 2usize; - let part = YellowBedPart::from_value(val / 1usize).unwrap(); - val -= (part.value() - 0usize) * 1usize; + let part = YellowBedPart::from_value(val / 8usize).unwrap(); + val -= (part.value() - 0usize) * 8usize; + let occupied = bool::from_value(val / 4usize).unwrap(); + val -= (occupied.value() - 0usize) * 4usize; + let facing = YellowBedFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { - facing, - occupied, part, + occupied, + facing, }) } } @@ -7191,6 +9172,15 @@ impl LimeBedData { m } } +impl Default for LimeBedData { + fn default() -> Self { + Self { + occupied: false, + part: LimeBedPart::Foot, + facing: LimeBedFacing::North, + } + } +} impl Value for LimeBedData { fn value(&self) -> usize { (self.occupied.value() * 8usize) @@ -7217,30 +9207,39 @@ impl Value for LimeBedData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct PinkBedData { - pub occupied: bool, pub part: PinkBedPart, + pub occupied: bool, pub facing: PinkBedFacing, } impl PinkBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - occupied: bool::from_snake_case(map.get("occupied")?)?, part: PinkBedPart::from_snake_case(map.get("part")?)?, + occupied: bool::from_snake_case(map.get("occupied")?)?, facing: PinkBedFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("occupied".to_string(), self.occupied.to_snake_case()); m.insert("part".to_string(), self.part.to_snake_case()); + m.insert("occupied".to_string(), self.occupied.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for PinkBedData { + fn default() -> Self { + Self { + part: PinkBedPart::Foot, + occupied: false, + facing: PinkBedFacing::North, + } + } +} impl Value for PinkBedData { fn value(&self) -> usize { - (self.occupied.value() * 8usize) - + (self.part.value() * 4usize) + (self.part.value() * 8usize) + + (self.occupied.value() * 4usize) + (self.facing.value() * 1usize) } #[allow(warnings)] @@ -7248,92 +9247,110 @@ impl Value for PinkBedData { if val >= 16usize { return None; } - let occupied = bool::from_value(val / 8usize).unwrap(); - val -= (occupied.value() - 0usize) * 8usize; - let part = PinkBedPart::from_value(val / 4usize).unwrap(); - val -= (part.value() - 0usize) * 4usize; + let part = PinkBedPart::from_value(val / 8usize).unwrap(); + val -= (part.value() - 0usize) * 8usize; + let occupied = bool::from_value(val / 4usize).unwrap(); + val -= (occupied.value() - 0usize) * 4usize; let facing = PinkBedFacing::from_value(val / 1usize).unwrap(); val -= (facing.value() - 0usize) * 1usize; Some(Self { - occupied, part, + occupied, facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct GrayBedData { + pub facing: GrayBedFacing, pub occupied: bool, pub part: GrayBedPart, - pub facing: GrayBedFacing, } impl GrayBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + facing: GrayBedFacing::from_snake_case(map.get("facing")?)?, occupied: bool::from_snake_case(map.get("occupied")?)?, part: GrayBedPart::from_snake_case(map.get("part")?)?, - facing: GrayBedFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("occupied".to_string(), self.occupied.to_snake_case()); m.insert("part".to_string(), self.part.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for GrayBedData { + fn default() -> Self { + Self { + facing: GrayBedFacing::North, + occupied: false, + part: GrayBedPart::Foot, + } + } +} impl Value for GrayBedData { fn value(&self) -> usize { - (self.occupied.value() * 8usize) - + (self.part.value() * 4usize) - + (self.facing.value() * 1usize) + (self.facing.value() * 4usize) + + (self.occupied.value() * 2usize) + + (self.part.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 16usize { return None; } - let occupied = bool::from_value(val / 8usize).unwrap(); - val -= (occupied.value() - 0usize) * 8usize; - let part = GrayBedPart::from_value(val / 4usize).unwrap(); - val -= (part.value() - 0usize) * 4usize; - let facing = GrayBedFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let facing = GrayBedFacing::from_value(val / 4usize).unwrap(); + val -= (facing.value() - 0usize) * 4usize; + let occupied = bool::from_value(val / 2usize).unwrap(); + val -= (occupied.value() - 0usize) * 2usize; + let part = GrayBedPart::from_value(val / 1usize).unwrap(); + val -= (part.value() - 0usize) * 1usize; Some(Self { + facing, occupied, part, - facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct LightGrayBedData { pub facing: LightGrayBedFacing, - pub part: LightGrayBedPart, pub occupied: bool, + pub part: LightGrayBedPart, } impl LightGrayBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { facing: LightGrayBedFacing::from_snake_case(map.get("facing")?)?, - part: LightGrayBedPart::from_snake_case(map.get("part")?)?, occupied: bool::from_snake_case(map.get("occupied")?)?, + part: LightGrayBedPart::from_snake_case(map.get("part")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("part".to_string(), self.part.to_snake_case()); m.insert("occupied".to_string(), self.occupied.to_snake_case()); + m.insert("part".to_string(), self.part.to_snake_case()); m } } +impl Default for LightGrayBedData { + fn default() -> Self { + Self { + facing: LightGrayBedFacing::North, + occupied: false, + part: LightGrayBedPart::Foot, + } + } +} impl Value for LightGrayBedData { fn value(&self) -> usize { (self.facing.value() * 4usize) - + (self.part.value() * 2usize) - + (self.occupied.value() * 1usize) + + (self.occupied.value() * 2usize) + + (self.part.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -7342,106 +9359,124 @@ impl Value for LightGrayBedData { } let facing = LightGrayBedFacing::from_value(val / 4usize).unwrap(); val -= (facing.value() - 0usize) * 4usize; - let part = LightGrayBedPart::from_value(val / 2usize).unwrap(); - val -= (part.value() - 0usize) * 2usize; - let occupied = bool::from_value(val / 1usize).unwrap(); - val -= (occupied.value() - 0usize) * 1usize; + let occupied = bool::from_value(val / 2usize).unwrap(); + val -= (occupied.value() - 0usize) * 2usize; + let part = LightGrayBedPart::from_value(val / 1usize).unwrap(); + val -= (part.value() - 0usize) * 1usize; Some(Self { facing, - part, occupied, + part, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct CyanBedData { - pub facing: CyanBedFacing, - pub part: CyanBedPart, pub occupied: bool, + pub part: CyanBedPart, + pub facing: CyanBedFacing, } impl CyanBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: CyanBedFacing::from_snake_case(map.get("facing")?)?, - part: CyanBedPart::from_snake_case(map.get("part")?)?, occupied: bool::from_snake_case(map.get("occupied")?)?, + part: CyanBedPart::from_snake_case(map.get("part")?)?, + facing: CyanBedFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("part".to_string(), self.part.to_snake_case()); m.insert("occupied".to_string(), self.occupied.to_snake_case()); + m.insert("part".to_string(), self.part.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for CyanBedData { + fn default() -> Self { + Self { + occupied: false, + part: CyanBedPart::Foot, + facing: CyanBedFacing::North, + } + } +} impl Value for CyanBedData { fn value(&self) -> usize { - (self.facing.value() * 4usize) - + (self.part.value() * 2usize) - + (self.occupied.value() * 1usize) + (self.occupied.value() * 8usize) + + (self.part.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 16usize { return None; } - let facing = CyanBedFacing::from_value(val / 4usize).unwrap(); - val -= (facing.value() - 0usize) * 4usize; - let part = CyanBedPart::from_value(val / 2usize).unwrap(); - val -= (part.value() - 0usize) * 2usize; - let occupied = bool::from_value(val / 1usize).unwrap(); - val -= (occupied.value() - 0usize) * 1usize; + let occupied = bool::from_value(val / 8usize).unwrap(); + val -= (occupied.value() - 0usize) * 8usize; + let part = CyanBedPart::from_value(val / 4usize).unwrap(); + val -= (part.value() - 0usize) * 4usize; + let facing = CyanBedFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { - facing, - part, occupied, + part, + facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct PurpleBedData { - pub occupied: bool, - pub facing: PurpleBedFacing, pub part: PurpleBedPart, + pub facing: PurpleBedFacing, + pub occupied: bool, } impl PurpleBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - occupied: bool::from_snake_case(map.get("occupied")?)?, - facing: PurpleBedFacing::from_snake_case(map.get("facing")?)?, part: PurpleBedPart::from_snake_case(map.get("part")?)?, + facing: PurpleBedFacing::from_snake_case(map.get("facing")?)?, + occupied: bool::from_snake_case(map.get("occupied")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("occupied".to_string(), self.occupied.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("part".to_string(), self.part.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("occupied".to_string(), self.occupied.to_snake_case()); m } } +impl Default for PurpleBedData { + fn default() -> Self { + Self { + part: PurpleBedPart::Foot, + facing: PurpleBedFacing::North, + occupied: false, + } + } +} impl Value for PurpleBedData { fn value(&self) -> usize { - (self.occupied.value() * 8usize) + (self.part.value() * 8usize) + (self.facing.value() * 2usize) - + (self.part.value() * 1usize) + + (self.occupied.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 16usize { return None; } - let occupied = bool::from_value(val / 8usize).unwrap(); - val -= (occupied.value() - 0usize) * 8usize; + let part = PurpleBedPart::from_value(val / 8usize).unwrap(); + val -= (part.value() - 0usize) * 8usize; let facing = PurpleBedFacing::from_value(val / 2usize).unwrap(); val -= (facing.value() - 0usize) * 2usize; - let part = PurpleBedPart::from_value(val / 1usize).unwrap(); - val -= (part.value() - 0usize) * 1usize; + let occupied = bool::from_value(val / 1usize).unwrap(); + val -= (occupied.value() - 0usize) * 1usize; Some(Self { - occupied, - facing, part, + facing, + occupied, }) } } @@ -7467,6 +9502,15 @@ impl BlueBedData { m } } +impl Default for BlueBedData { + fn default() -> Self { + Self { + facing: BlueBedFacing::North, + occupied: false, + part: BlueBedPart::Foot, + } + } +} impl Value for BlueBedData { fn value(&self) -> usize { (self.facing.value() * 4usize) @@ -7493,139 +9537,166 @@ impl Value for BlueBedData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BrownBedData { - pub occupied: bool, pub facing: BrownBedFacing, pub part: BrownBedPart, + pub occupied: bool, } impl BrownBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - occupied: bool::from_snake_case(map.get("occupied")?)?, facing: BrownBedFacing::from_snake_case(map.get("facing")?)?, part: BrownBedPart::from_snake_case(map.get("part")?)?, + occupied: bool::from_snake_case(map.get("occupied")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("occupied".to_string(), self.occupied.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("part".to_string(), self.part.to_snake_case()); + m.insert("occupied".to_string(), self.occupied.to_snake_case()); m } } +impl Default for BrownBedData { + fn default() -> Self { + Self { + facing: BrownBedFacing::North, + part: BrownBedPart::Foot, + occupied: false, + } + } +} impl Value for BrownBedData { fn value(&self) -> usize { - (self.occupied.value() * 8usize) - + (self.facing.value() * 2usize) - + (self.part.value() * 1usize) + (self.facing.value() * 4usize) + + (self.part.value() * 2usize) + + (self.occupied.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 16usize { return None; } - let occupied = bool::from_value(val / 8usize).unwrap(); - val -= (occupied.value() - 0usize) * 8usize; - let facing = BrownBedFacing::from_value(val / 2usize).unwrap(); - val -= (facing.value() - 0usize) * 2usize; - let part = BrownBedPart::from_value(val / 1usize).unwrap(); - val -= (part.value() - 0usize) * 1usize; + let facing = BrownBedFacing::from_value(val / 4usize).unwrap(); + val -= (facing.value() - 0usize) * 4usize; + let part = BrownBedPart::from_value(val / 2usize).unwrap(); + val -= (part.value() - 0usize) * 2usize; + let occupied = bool::from_value(val / 1usize).unwrap(); + val -= (occupied.value() - 0usize) * 1usize; Some(Self { - occupied, facing, part, + occupied, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct GreenBedData { + pub occupied: bool, pub facing: GreenBedFacing, pub part: GreenBedPart, - pub occupied: bool, } impl GreenBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + occupied: bool::from_snake_case(map.get("occupied")?)?, facing: GreenBedFacing::from_snake_case(map.get("facing")?)?, part: GreenBedPart::from_snake_case(map.get("part")?)?, - occupied: bool::from_snake_case(map.get("occupied")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("occupied".to_string(), self.occupied.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("part".to_string(), self.part.to_snake_case()); - m.insert("occupied".to_string(), self.occupied.to_snake_case()); m } } +impl Default for GreenBedData { + fn default() -> Self { + Self { + occupied: false, + facing: GreenBedFacing::North, + part: GreenBedPart::Foot, + } + } +} impl Value for GreenBedData { fn value(&self) -> usize { - (self.facing.value() * 4usize) - + (self.part.value() * 2usize) - + (self.occupied.value() * 1usize) + (self.occupied.value() * 8usize) + + (self.facing.value() * 2usize) + + (self.part.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 16usize { return None; } - let facing = GreenBedFacing::from_value(val / 4usize).unwrap(); - val -= (facing.value() - 0usize) * 4usize; - let part = GreenBedPart::from_value(val / 2usize).unwrap(); - val -= (part.value() - 0usize) * 2usize; - let occupied = bool::from_value(val / 1usize).unwrap(); - val -= (occupied.value() - 0usize) * 1usize; + let occupied = bool::from_value(val / 8usize).unwrap(); + val -= (occupied.value() - 0usize) * 8usize; + let facing = GreenBedFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let part = GreenBedPart::from_value(val / 1usize).unwrap(); + val -= (part.value() - 0usize) * 1usize; Some(Self { + occupied, facing, part, - occupied, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct RedBedData { + pub occupied: bool, pub part: RedBedPart, pub facing: RedBedFacing, - pub occupied: bool, } impl RedBedData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + occupied: bool::from_snake_case(map.get("occupied")?)?, part: RedBedPart::from_snake_case(map.get("part")?)?, facing: RedBedFacing::from_snake_case(map.get("facing")?)?, - occupied: bool::from_snake_case(map.get("occupied")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("occupied".to_string(), self.occupied.to_snake_case()); m.insert("part".to_string(), self.part.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("occupied".to_string(), self.occupied.to_snake_case()); m } } +impl Default for RedBedData { + fn default() -> Self { + Self { + occupied: false, + part: RedBedPart::Foot, + facing: RedBedFacing::North, + } + } +} impl Value for RedBedData { fn value(&self) -> usize { - (self.part.value() * 8usize) - + (self.facing.value() * 2usize) - + (self.occupied.value() * 1usize) + (self.occupied.value() * 8usize) + + (self.part.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 16usize { return None; } - let part = RedBedPart::from_value(val / 8usize).unwrap(); - val -= (part.value() - 0usize) * 8usize; - let facing = RedBedFacing::from_value(val / 2usize).unwrap(); - val -= (facing.value() - 0usize) * 2usize; - let occupied = bool::from_value(val / 1usize).unwrap(); - val -= (occupied.value() - 0usize) * 1usize; + let occupied = bool::from_value(val / 8usize).unwrap(); + val -= (occupied.value() - 0usize) * 8usize; + let part = RedBedPart::from_value(val / 4usize).unwrap(); + val -= (part.value() - 0usize) * 4usize; + let facing = RedBedFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { + occupied, part, facing, - occupied, }) } } @@ -7651,6 +9722,15 @@ impl BlackBedData { m } } +impl Default for BlackBedData { + fn default() -> Self { + Self { + occupied: false, + part: BlackBedPart::Foot, + facing: BlackBedFacing::North, + } + } +} impl Value for BlackBedData { fn value(&self) -> usize { (self.occupied.value() * 8usize) @@ -7677,72 +9757,88 @@ impl Value for BlackBedData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct PoweredRailData { - pub powered: bool, pub shape: PoweredRailShape, + pub powered: bool, } impl PoweredRailData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - powered: bool::from_snake_case(map.get("powered")?)?, shape: PoweredRailShape::from_snake_case(map.get("shape")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for PoweredRailData { + fn default() -> Self { + Self { + shape: PoweredRailShape::NorthSouth, + powered: false, + } + } +} impl Value for PoweredRailData { fn value(&self) -> usize { - (self.powered.value() * 6usize) + (self.shape.value() * 1usize) + (self.shape.value() * 2usize) + (self.powered.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 12usize { return None; } - let powered = bool::from_value(val / 6usize).unwrap(); - val -= (powered.value() - 0usize) * 6usize; - let shape = PoweredRailShape::from_value(val / 1usize).unwrap(); - val -= (shape.value() - 0usize) * 1usize; - Some(Self { powered, shape }) + let shape = PoweredRailShape::from_value(val / 2usize).unwrap(); + val -= (shape.value() - 0usize) * 2usize; + let powered = bool::from_value(val / 1usize).unwrap(); + val -= (powered.value() - 0usize) * 1usize; + Some(Self { shape, powered }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DetectorRailData { - pub shape: DetectorRailShape, pub powered: bool, + pub shape: DetectorRailShape, } impl DetectorRailData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - shape: DetectorRailShape::from_snake_case(map.get("shape")?)?, powered: bool::from_snake_case(map.get("powered")?)?, + shape: DetectorRailShape::from_snake_case(map.get("shape")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("shape".to_string(), self.shape.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); + m.insert("shape".to_string(), self.shape.to_snake_case()); m } } +impl Default for DetectorRailData { + fn default() -> Self { + Self { + powered: false, + shape: DetectorRailShape::NorthSouth, + } + } +} impl Value for DetectorRailData { fn value(&self) -> usize { - (self.shape.value() * 2usize) + (self.powered.value() * 1usize) + (self.powered.value() * 6usize) + (self.shape.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 12usize { return None; } - let shape = DetectorRailShape::from_value(val / 2usize).unwrap(); - val -= (shape.value() - 0usize) * 2usize; - let powered = bool::from_value(val / 1usize).unwrap(); - val -= (powered.value() - 0usize) * 1usize; - Some(Self { shape, powered }) + let powered = bool::from_value(val / 6usize).unwrap(); + val -= (powered.value() - 0usize) * 6usize; + let shape = DetectorRailShape::from_value(val / 1usize).unwrap(); + val -= (shape.value() - 0usize) * 1usize; + Some(Self { powered, shape }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] @@ -7764,6 +9860,14 @@ impl StickyPistonData { m } } +impl Default for StickyPistonData { + fn default() -> Self { + Self { + extended: false, + facing: StickyPistonFacing::North, + } + } +} impl Value for StickyPistonData { fn value(&self) -> usize { (self.extended.value() * 6usize) + (self.facing.value() * 1usize) @@ -7796,6 +9900,13 @@ impl TallSeagrassData { m } } +impl Default for TallSeagrassData { + fn default() -> Self { + Self { + half: TallSeagrassHalf::Lower, + } + } +} impl Value for TallSeagrassData { fn value(&self) -> usize { (self.half.value() * 1usize) @@ -7812,112 +9923,137 @@ impl Value for TallSeagrassData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct PistonData { - pub extended: bool, pub facing: PistonFacing, + pub extended: bool, } impl PistonData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - extended: bool::from_snake_case(map.get("extended")?)?, facing: PistonFacing::from_snake_case(map.get("facing")?)?, + extended: bool::from_snake_case(map.get("extended")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("extended".to_string(), self.extended.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("extended".to_string(), self.extended.to_snake_case()); m } } +impl Default for PistonData { + fn default() -> Self { + Self { + facing: PistonFacing::North, + extended: false, + } + } +} impl Value for PistonData { fn value(&self) -> usize { - (self.extended.value() * 6usize) + (self.facing.value() * 1usize) + (self.facing.value() * 2usize) + (self.extended.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 12usize { return None; } - let extended = bool::from_value(val / 6usize).unwrap(); - val -= (extended.value() - 0usize) * 6usize; - let facing = PistonFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; - Some(Self { extended, facing }) + let facing = PistonFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let extended = bool::from_value(val / 1usize).unwrap(); + val -= (extended.value() - 0usize) * 1usize; + Some(Self { facing, extended }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct PistonHeadData { - pub ty: PistonHeadType, pub short: bool, + pub ty: PistonHeadType, pub facing: PistonHeadFacing, } impl PistonHeadData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - ty: PistonHeadType::from_snake_case(map.get("type")?)?, short: bool::from_snake_case(map.get("short")?)?, + ty: PistonHeadType::from_snake_case(map.get("type")?)?, facing: PistonHeadFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("type".to_string(), self.ty.to_snake_case()); m.insert("short".to_string(), self.short.to_snake_case()); + m.insert("type".to_string(), self.ty.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for PistonHeadData { + fn default() -> Self { + Self { + short: false, + ty: PistonHeadType::Normal, + facing: PistonHeadFacing::North, + } + } +} impl Value for PistonHeadData { fn value(&self) -> usize { - (self.ty.value() * 12usize) + (self.short.value() * 6usize) + (self.facing.value() * 1usize) + (self.short.value() * 12usize) + (self.ty.value() * 6usize) + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 24usize { return None; } - let ty = PistonHeadType::from_value(val / 12usize).unwrap(); - val -= (ty.value() - 0usize) * 12usize; - let short = bool::from_value(val / 6usize).unwrap(); - val -= (short.value() - 0usize) * 6usize; + let short = bool::from_value(val / 12usize).unwrap(); + val -= (short.value() - 0usize) * 12usize; + let ty = PistonHeadType::from_value(val / 6usize).unwrap(); + val -= (ty.value() - 0usize) * 6usize; let facing = PistonHeadFacing::from_value(val / 1usize).unwrap(); val -= (facing.value() - 0usize) * 1usize; - Some(Self { ty, short, facing }) + Some(Self { short, ty, facing }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct MovingPistonData { - pub ty: MovingPistonType, pub facing: MovingPistonFacing, + pub ty: MovingPistonType, } impl MovingPistonData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - ty: MovingPistonType::from_snake_case(map.get("type")?)?, facing: MovingPistonFacing::from_snake_case(map.get("facing")?)?, + ty: MovingPistonType::from_snake_case(map.get("type")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("type".to_string(), self.ty.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("type".to_string(), self.ty.to_snake_case()); m } } +impl Default for MovingPistonData { + fn default() -> Self { + Self { + facing: MovingPistonFacing::North, + ty: MovingPistonType::Normal, + } + } +} impl Value for MovingPistonData { fn value(&self) -> usize { - (self.ty.value() * 6usize) + (self.facing.value() * 1usize) + (self.facing.value() * 2usize) + (self.ty.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 12usize { return None; } - let ty = MovingPistonType::from_value(val / 6usize).unwrap(); - val -= (ty.value() - 0usize) * 6usize; - let facing = MovingPistonFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; - Some(Self { ty, facing }) + let facing = MovingPistonFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let ty = MovingPistonType::from_value(val / 1usize).unwrap(); + val -= (ty.value() - 0usize) * 1usize; + Some(Self { facing, ty }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] @@ -7936,6 +10072,11 @@ impl TntData { m } } +impl Default for TntData { + fn default() -> Self { + Self { unstable: false } + } +} impl Value for TntData { fn value(&self) -> usize { (self.unstable.value() * 1usize) @@ -7966,6 +10107,13 @@ impl WallTorchData { m } } +impl Default for WallTorchData { + fn default() -> Self { + Self { + facing: WallTorchFacing::North, + } + } +} impl Value for WallTorchData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -7982,227 +10130,269 @@ impl Value for WallTorchData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct FireData { - pub east: bool, - pub north: bool, - pub south: bool, - pub up: bool, pub west: bool, + pub north: bool, + pub east: bool, pub age: i32, + pub up: bool, + pub south: bool, } impl FireData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - east: bool::from_snake_case(map.get("east")?)?, - north: bool::from_snake_case(map.get("north")?)?, - south: bool::from_snake_case(map.get("south")?)?, - up: bool::from_snake_case(map.get("up")?)?, west: bool::from_snake_case(map.get("west")?)?, + north: bool::from_snake_case(map.get("north")?)?, + east: bool::from_snake_case(map.get("east")?)?, age: i32::from_snake_case(map.get("age")?)?, + up: bool::from_snake_case(map.get("up")?)?, + south: bool::from_snake_case(map.get("south")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("up".to_string(), self.up.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("north".to_string(), self.north.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m.insert("age".to_string(), self.age.to_snake_case()); + m.insert("up".to_string(), self.up.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); m } } +impl Default for FireData { + fn default() -> Self { + Self { + west: false, + north: false, + east: false, + age: 0, + up: false, + south: false, + } + } +} impl Value for FireData { fn value(&self) -> usize { - (self.east.value() * 256usize) + (self.west.value() * 256usize) + (self.north.value() * 128usize) - + (self.south.value() * 64usize) - + (self.up.value() * 32usize) - + (self.west.value() * 16usize) - + (self.age.value() * 1usize) + + (self.east.value() * 64usize) + + (self.age.value() * 4usize) + + (self.up.value() * 2usize) + + (self.south.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 512usize { return None; } - let east = bool::from_value(val / 256usize).unwrap(); - val -= (east.value() - 0usize) * 256usize; + let west = bool::from_value(val / 256usize).unwrap(); + val -= (west.value() - 0usize) * 256usize; let north = bool::from_value(val / 128usize).unwrap(); val -= (north.value() - 0usize) * 128usize; - let south = bool::from_value(val / 64usize).unwrap(); - val -= (south.value() - 0usize) * 64usize; - let up = bool::from_value(val / 32usize).unwrap(); - val -= (up.value() - 0usize) * 32usize; - let west = bool::from_value(val / 16usize).unwrap(); - val -= (west.value() - 0usize) * 16usize; - let age = i32::from_value(val / 1usize).unwrap(); - val -= (age.value() - 0usize) * 1usize; + let east = bool::from_value(val / 64usize).unwrap(); + val -= (east.value() - 0usize) * 64usize; + let age = i32::from_value(val / 4usize).unwrap(); + val -= (age.value() - 0usize) * 4usize; + let up = bool::from_value(val / 2usize).unwrap(); + val -= (up.value() - 0usize) * 2usize; + let south = bool::from_value(val / 1usize).unwrap(); + val -= (south.value() - 0usize) * 1usize; Some(Self { - east, - north, - south, - up, west, + north, + east, age, + up, + south, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct OakStairsData { - pub facing: OakStairsFacing, + pub half: OakStairsHalf, pub shape: OakStairsShape, + pub facing: OakStairsFacing, pub waterlogged: bool, - pub half: OakStairsHalf, } impl OakStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: OakStairsFacing::from_snake_case(map.get("facing")?)?, + half: OakStairsHalf::from_snake_case(map.get("half")?)?, shape: OakStairsShape::from_snake_case(map.get("shape")?)?, + facing: OakStairsFacing::from_snake_case(map.get("facing")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - half: OakStairsHalf::from_snake_case(map.get("half")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); m } } +impl Default for OakStairsData { + fn default() -> Self { + Self { + half: OakStairsHalf::Bottom, + shape: OakStairsShape::Straight, + facing: OakStairsFacing::North, + waterlogged: false, + } + } +} impl Value for OakStairsData { fn value(&self) -> usize { - (self.facing.value() * 20usize) - + (self.shape.value() * 4usize) - + (self.waterlogged.value() * 2usize) - + (self.half.value() * 1usize) + (self.half.value() * 40usize) + + (self.shape.value() * 8usize) + + (self.facing.value() * 2usize) + + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 80usize { return None; } - let facing = OakStairsFacing::from_value(val / 20usize).unwrap(); - val -= (facing.value() - 0usize) * 20usize; - let shape = OakStairsShape::from_value(val / 4usize).unwrap(); - val -= (shape.value() - 0usize) * 4usize; - let waterlogged = bool::from_value(val / 2usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 2usize; - let half = OakStairsHalf::from_value(val / 1usize).unwrap(); - val -= (half.value() - 0usize) * 1usize; + let half = OakStairsHalf::from_value(val / 40usize).unwrap(); + val -= (half.value() - 0usize) * 40usize; + let shape = OakStairsShape::from_value(val / 8usize).unwrap(); + val -= (shape.value() - 0usize) * 8usize; + let facing = OakStairsFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { - facing, + half, shape, + facing, waterlogged, - half, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct ChestData { + pub ty: ChestType, pub waterlogged: bool, pub facing: ChestFacing, - pub ty: ChestType, } impl ChestData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + ty: ChestType::from_snake_case(map.get("type")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, facing: ChestFacing::from_snake_case(map.get("facing")?)?, - ty: ChestType::from_snake_case(map.get("type")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("type".to_string(), self.ty.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("type".to_string(), self.ty.to_snake_case()); m } } +impl Default for ChestData { + fn default() -> Self { + Self { + ty: ChestType::Single, + waterlogged: false, + facing: ChestFacing::North, + } + } +} impl Value for ChestData { fn value(&self) -> usize { - (self.waterlogged.value() * 12usize) - + (self.facing.value() * 3usize) - + (self.ty.value() * 1usize) + (self.ty.value() * 8usize) + + (self.waterlogged.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 24usize { return None; } - let waterlogged = bool::from_value(val / 12usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 12usize; - let facing = ChestFacing::from_value(val / 3usize).unwrap(); - val -= (facing.value() - 0usize) * 3usize; - let ty = ChestType::from_value(val / 1usize).unwrap(); - val -= (ty.value() - 0usize) * 1usize; + let ty = ChestType::from_value(val / 8usize).unwrap(); + val -= (ty.value() - 0usize) * 8usize; + let waterlogged = bool::from_value(val / 4usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 4usize; + let facing = ChestFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { + ty, waterlogged, facing, - ty, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct RedstoneWireData { + pub west: RedstoneWireWest, pub north: RedstoneWireNorth, - pub power: i32, pub east: RedstoneWireEast, pub south: RedstoneWireSouth, - pub west: RedstoneWireWest, + pub power: i32, } impl RedstoneWireData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + west: RedstoneWireWest::from_snake_case(map.get("west")?)?, north: RedstoneWireNorth::from_snake_case(map.get("north")?)?, - power: i32::from_snake_case(map.get("power")?)?, east: RedstoneWireEast::from_snake_case(map.get("east")?)?, south: RedstoneWireSouth::from_snake_case(map.get("south")?)?, - west: RedstoneWireWest::from_snake_case(map.get("west")?)?, + power: i32::from_snake_case(map.get("power")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("west".to_string(), self.west.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("power".to_string(), self.power.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("power".to_string(), self.power.to_snake_case()); m } } +impl Default for RedstoneWireData { + fn default() -> Self { + Self { + west: RedstoneWireWest::None, + north: RedstoneWireNorth::None, + east: RedstoneWireEast::None, + south: RedstoneWireSouth::None, + power: 0, + } + } +} impl Value for RedstoneWireData { fn value(&self) -> usize { - (self.north.value() * 432usize) - + (self.power.value() * 27usize) - + (self.east.value() * 9usize) - + (self.south.value() * 3usize) - + (self.west.value() * 1usize) + (self.west.value() * 432usize) + + (self.north.value() * 144usize) + + (self.east.value() * 48usize) + + (self.south.value() * 16usize) + + (self.power.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 1296usize { return None; } - let north = RedstoneWireNorth::from_value(val / 432usize).unwrap(); - val -= (north.value() - 0usize) * 432usize; - let power = i32::from_value(val / 27usize).unwrap(); - val -= (power.value() - 0usize) * 27usize; - let east = RedstoneWireEast::from_value(val / 9usize).unwrap(); - val -= (east.value() - 0usize) * 9usize; - let south = RedstoneWireSouth::from_value(val / 3usize).unwrap(); - val -= (south.value() - 0usize) * 3usize; - let west = RedstoneWireWest::from_value(val / 1usize).unwrap(); - val -= (west.value() - 0usize) * 1usize; + let west = RedstoneWireWest::from_value(val / 432usize).unwrap(); + val -= (west.value() - 0usize) * 432usize; + let north = RedstoneWireNorth::from_value(val / 144usize).unwrap(); + val -= (north.value() - 0usize) * 144usize; + let east = RedstoneWireEast::from_value(val / 48usize).unwrap(); + val -= (east.value() - 0usize) * 48usize; + let south = RedstoneWireSouth::from_value(val / 16usize).unwrap(); + val -= (south.value() - 0usize) * 16usize; + let power = i32::from_value(val / 1usize).unwrap(); + val -= (power.value() - 0usize) * 1usize; Some(Self { + west, north, - power, east, south, - west, + power, }) } } @@ -8222,6 +10412,11 @@ impl WheatData { m } } +impl Default for WheatData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for WheatData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -8252,6 +10447,11 @@ impl FarmlandData { m } } +impl Default for FarmlandData { + fn default() -> Self { + Self { moisture: 0 } + } +} impl Value for FarmlandData { fn value(&self) -> usize { (self.moisture.value() * 1usize) @@ -8285,6 +10485,14 @@ impl FurnaceData { m } } +impl Default for FurnaceData { + fn default() -> Self { + Self { + facing: FurnaceFacing::North, + lit: false, + } + } +} impl Value for FurnaceData { fn value(&self) -> usize { (self.facing.value() * 2usize) + (self.lit.value() * 1usize) @@ -8320,6 +10528,14 @@ impl SignData { m } } +impl Default for SignData { + fn default() -> Self { + Self { + rotation: 0, + waterlogged: false, + } + } +} impl Value for SignData { fn value(&self) -> usize { (self.rotation.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -8341,37 +10557,48 @@ impl Value for SignData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct OakDoorData { - pub facing: OakDoorFacing, pub half: OakDoorHalf, pub powered: bool, + pub facing: OakDoorFacing, pub open: bool, pub hinge: OakDoorHinge, } impl OakDoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: OakDoorFacing::from_snake_case(map.get("facing")?)?, half: OakDoorHalf::from_snake_case(map.get("half")?)?, powered: bool::from_snake_case(map.get("powered")?)?, + facing: OakDoorFacing::from_snake_case(map.get("facing")?)?, open: bool::from_snake_case(map.get("open")?)?, hinge: OakDoorHinge::from_snake_case(map.get("hinge")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); m.insert("hinge".to_string(), self.hinge.to_snake_case()); m } } +impl Default for OakDoorData { + fn default() -> Self { + Self { + half: OakDoorHalf::Lower, + powered: false, + facing: OakDoorFacing::North, + open: false, + hinge: OakDoorHinge::Left, + } + } +} impl Value for OakDoorData { fn value(&self) -> usize { - (self.facing.value() * 16usize) - + (self.half.value() * 8usize) - + (self.powered.value() * 4usize) + (self.half.value() * 32usize) + + (self.powered.value() * 16usize) + + (self.facing.value() * 4usize) + (self.open.value() * 2usize) + (self.hinge.value() * 1usize) } @@ -8380,20 +10607,20 @@ impl Value for OakDoorData { if val >= 64usize { return None; } - let facing = OakDoorFacing::from_value(val / 16usize).unwrap(); - val -= (facing.value() - 0usize) * 16usize; - let half = OakDoorHalf::from_value(val / 8usize).unwrap(); - val -= (half.value() - 0usize) * 8usize; - let powered = bool::from_value(val / 4usize).unwrap(); - val -= (powered.value() - 0usize) * 4usize; + let half = OakDoorHalf::from_value(val / 32usize).unwrap(); + val -= (half.value() - 0usize) * 32usize; + let powered = bool::from_value(val / 16usize).unwrap(); + val -= (powered.value() - 0usize) * 16usize; + let facing = OakDoorFacing::from_value(val / 4usize).unwrap(); + val -= (facing.value() - 0usize) * 4usize; let open = bool::from_value(val / 2usize).unwrap(); val -= (open.value() - 0usize) * 2usize; let hinge = OakDoorHinge::from_value(val / 1usize).unwrap(); val -= (hinge.value() - 0usize) * 1usize; Some(Self { - facing, half, powered, + facing, open, hinge, }) @@ -8401,39 +10628,47 @@ impl Value for OakDoorData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct LadderData { - pub waterlogged: bool, pub facing: LadderFacing, + pub waterlogged: bool, } impl LadderData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, facing: LadderFacing::from_snake_case(map.get("facing")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for LadderData { + fn default() -> Self { + Self { + facing: LadderFacing::North, + waterlogged: false, + } + } +} impl Value for LadderData { fn value(&self) -> usize { - (self.waterlogged.value() * 4usize) + (self.facing.value() * 1usize) + (self.facing.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 8usize { return None; } - let waterlogged = bool::from_value(val / 4usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 4usize; - let facing = LadderFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let facing = LadderFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { - waterlogged, facing, + waterlogged, }) } } @@ -8453,6 +10688,13 @@ impl RailData { m } } +impl Default for RailData { + fn default() -> Self { + Self { + shape: RailShape::NorthSouth, + } + } +} impl Value for RailData { fn value(&self) -> usize { (self.shape.value() * 1usize) @@ -8470,34 +10712,44 @@ impl Value for RailData { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct CobblestoneStairsData { pub waterlogged: bool, + pub facing: CobblestoneStairsFacing, pub half: CobblestoneStairsHalf, pub shape: CobblestoneStairsShape, - pub facing: CobblestoneStairsFacing, } impl CobblestoneStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + facing: CobblestoneStairsFacing::from_snake_case(map.get("facing")?)?, half: CobblestoneStairsHalf::from_snake_case(map.get("half")?)?, shape: CobblestoneStairsShape::from_snake_case(map.get("shape")?)?, - facing: CobblestoneStairsFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for CobblestoneStairsData { + fn default() -> Self { + Self { + waterlogged: false, + facing: CobblestoneStairsFacing::North, + half: CobblestoneStairsHalf::Bottom, + shape: CobblestoneStairsShape::Straight, + } + } +} impl Value for CobblestoneStairsData { fn value(&self) -> usize { (self.waterlogged.value() * 40usize) - + (self.half.value() * 20usize) - + (self.shape.value() * 4usize) - + (self.facing.value() * 1usize) + + (self.facing.value() * 10usize) + + (self.half.value() * 5usize) + + (self.shape.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -8506,17 +10758,17 @@ impl Value for CobblestoneStairsData { } let waterlogged = bool::from_value(val / 40usize).unwrap(); val -= (waterlogged.value() - 0usize) * 40usize; - let half = CobblestoneStairsHalf::from_value(val / 20usize).unwrap(); - val -= (half.value() - 0usize) * 20usize; - let shape = CobblestoneStairsShape::from_value(val / 4usize).unwrap(); - val -= (shape.value() - 0usize) * 4usize; - let facing = CobblestoneStairsFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let facing = CobblestoneStairsFacing::from_value(val / 10usize).unwrap(); + val -= (facing.value() - 0usize) * 10usize; + let half = CobblestoneStairsHalf::from_value(val / 5usize).unwrap(); + val -= (half.value() - 0usize) * 5usize; + let shape = CobblestoneStairsShape::from_value(val / 1usize).unwrap(); + val -= (shape.value() - 0usize) * 1usize; Some(Self { waterlogged, + facing, half, shape, - facing, }) } } @@ -8539,6 +10791,14 @@ impl WallSignData { m } } +impl Default for WallSignData { + fn default() -> Self { + Self { + waterlogged: false, + facing: WallSignFacing::North, + } + } +} impl Value for WallSignData { fn value(&self) -> usize { (self.waterlogged.value() * 4usize) + (self.facing.value() * 1usize) @@ -8560,47 +10820,56 @@ impl Value for WallSignData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct LeverData { - pub powered: bool, pub facing: LeverFacing, pub face: LeverFace, + pub powered: bool, } impl LeverData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - powered: bool::from_snake_case(map.get("powered")?)?, facing: LeverFacing::from_snake_case(map.get("facing")?)?, face: LeverFace::from_snake_case(map.get("face")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("face".to_string(), self.face.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for LeverData { + fn default() -> Self { + Self { + facing: LeverFacing::North, + face: LeverFace::Wall, + powered: false, + } + } +} impl Value for LeverData { fn value(&self) -> usize { - (self.powered.value() * 12usize) - + (self.facing.value() * 3usize) - + (self.face.value() * 1usize) + (self.facing.value() * 6usize) + + (self.face.value() * 2usize) + + (self.powered.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 24usize { return None; } - let powered = bool::from_value(val / 12usize).unwrap(); - val -= (powered.value() - 0usize) * 12usize; - let facing = LeverFacing::from_value(val / 3usize).unwrap(); - val -= (facing.value() - 0usize) * 3usize; - let face = LeverFace::from_value(val / 1usize).unwrap(); - val -= (face.value() - 0usize) * 1usize; + let facing = LeverFacing::from_value(val / 6usize).unwrap(); + val -= (facing.value() - 0usize) * 6usize; + let face = LeverFace::from_value(val / 2usize).unwrap(); + val -= (face.value() - 0usize) * 2usize; + let powered = bool::from_value(val / 1usize).unwrap(); + val -= (powered.value() - 0usize) * 1usize; Some(Self { - powered, facing, face, + powered, }) } } @@ -8620,6 +10889,11 @@ impl StonePressurePlateData { m } } +impl Default for StonePressurePlateData { + fn default() -> Self { + Self { powered: false } + } +} impl Value for StonePressurePlateData { fn value(&self) -> usize { (self.powered.value() * 1usize) @@ -8636,61 +10910,72 @@ impl Value for StonePressurePlateData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct IronDoorData { - pub facing: IronDoorFacing, - pub powered: bool, - pub open: bool, pub half: IronDoorHalf, + pub open: bool, + pub facing: IronDoorFacing, pub hinge: IronDoorHinge, + pub powered: bool, } impl IronDoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: IronDoorFacing::from_snake_case(map.get("facing")?)?, - powered: bool::from_snake_case(map.get("powered")?)?, - open: bool::from_snake_case(map.get("open")?)?, half: IronDoorHalf::from_snake_case(map.get("half")?)?, + open: bool::from_snake_case(map.get("open")?)?, + facing: IronDoorFacing::from_snake_case(map.get("facing")?)?, hinge: IronDoorHinge::from_snake_case(map.get("hinge")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("powered".to_string(), self.powered.to_snake_case()); - m.insert("open".to_string(), self.open.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("open".to_string(), self.open.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("hinge".to_string(), self.hinge.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for IronDoorData { + fn default() -> Self { + Self { + half: IronDoorHalf::Lower, + open: false, + facing: IronDoorFacing::North, + hinge: IronDoorHinge::Left, + powered: false, + } + } +} impl Value for IronDoorData { fn value(&self) -> usize { - (self.facing.value() * 16usize) - + (self.powered.value() * 8usize) - + (self.open.value() * 4usize) - + (self.half.value() * 2usize) - + (self.hinge.value() * 1usize) + (self.half.value() * 32usize) + + (self.open.value() * 16usize) + + (self.facing.value() * 4usize) + + (self.hinge.value() * 2usize) + + (self.powered.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 64usize { return None; } - let facing = IronDoorFacing::from_value(val / 16usize).unwrap(); - val -= (facing.value() - 0usize) * 16usize; - let powered = bool::from_value(val / 8usize).unwrap(); - val -= (powered.value() - 0usize) * 8usize; - let open = bool::from_value(val / 4usize).unwrap(); - val -= (open.value() - 0usize) * 4usize; - let half = IronDoorHalf::from_value(val / 2usize).unwrap(); - val -= (half.value() - 0usize) * 2usize; - let hinge = IronDoorHinge::from_value(val / 1usize).unwrap(); - val -= (hinge.value() - 0usize) * 1usize; + let half = IronDoorHalf::from_value(val / 32usize).unwrap(); + val -= (half.value() - 0usize) * 32usize; + let open = bool::from_value(val / 16usize).unwrap(); + val -= (open.value() - 0usize) * 16usize; + let facing = IronDoorFacing::from_value(val / 4usize).unwrap(); + val -= (facing.value() - 0usize) * 4usize; + let hinge = IronDoorHinge::from_value(val / 2usize).unwrap(); + val -= (hinge.value() - 0usize) * 2usize; + let powered = bool::from_value(val / 1usize).unwrap(); + val -= (powered.value() - 0usize) * 1usize; Some(Self { - facing, - powered, - open, half, + open, + facing, hinge, + powered, }) } } @@ -8710,6 +10995,11 @@ impl OakPressurePlateData { m } } +impl Default for OakPressurePlateData { + fn default() -> Self { + Self { powered: false } + } +} impl Value for OakPressurePlateData { fn value(&self) -> usize { (self.powered.value() * 1usize) @@ -8740,6 +11030,11 @@ impl SprucePressurePlateData { m } } +impl Default for SprucePressurePlateData { + fn default() -> Self { + Self { powered: false } + } +} impl Value for SprucePressurePlateData { fn value(&self) -> usize { (self.powered.value() * 1usize) @@ -8770,6 +11065,11 @@ impl BirchPressurePlateData { m } } +impl Default for BirchPressurePlateData { + fn default() -> Self { + Self { powered: false } + } +} impl Value for BirchPressurePlateData { fn value(&self) -> usize { (self.powered.value() * 1usize) @@ -8800,6 +11100,11 @@ impl JunglePressurePlateData { m } } +impl Default for JunglePressurePlateData { + fn default() -> Self { + Self { powered: false } + } +} impl Value for JunglePressurePlateData { fn value(&self) -> usize { (self.powered.value() * 1usize) @@ -8830,6 +11135,11 @@ impl AcaciaPressurePlateData { m } } +impl Default for AcaciaPressurePlateData { + fn default() -> Self { + Self { powered: false } + } +} impl Value for AcaciaPressurePlateData { fn value(&self) -> usize { (self.powered.value() * 1usize) @@ -8860,6 +11170,11 @@ impl DarkOakPressurePlateData { m } } +impl Default for DarkOakPressurePlateData { + fn default() -> Self { + Self { powered: false } + } +} impl Value for DarkOakPressurePlateData { fn value(&self) -> usize { (self.powered.value() * 1usize) @@ -8890,6 +11205,11 @@ impl RedstoneOreData { m } } +impl Default for RedstoneOreData { + fn default() -> Self { + Self { lit: false } + } +} impl Value for RedstoneOreData { fn value(&self) -> usize { (self.lit.value() * 1usize) @@ -8920,6 +11240,11 @@ impl RedstoneTorchData { m } } +impl Default for RedstoneTorchData { + fn default() -> Self { + Self { lit: true } + } +} impl Value for RedstoneTorchData { fn value(&self) -> usize { (self.lit.value() * 1usize) @@ -8953,6 +11278,14 @@ impl RedstoneWallTorchData { m } } +impl Default for RedstoneWallTorchData { + fn default() -> Self { + Self { + facing: RedstoneWallTorchFacing::North, + lit: true, + } + } +} impl Value for RedstoneWallTorchData { fn value(&self) -> usize { (self.facing.value() * 2usize) + (self.lit.value() * 1usize) @@ -8991,6 +11324,15 @@ impl StoneButtonData { m } } +impl Default for StoneButtonData { + fn default() -> Self { + Self { + powered: false, + face: StoneButtonFace::Wall, + facing: StoneButtonFacing::North, + } + } +} impl Value for StoneButtonData { fn value(&self) -> usize { (self.powered.value() * 12usize) @@ -9031,6 +11373,11 @@ impl SnowData { m } } +impl Default for SnowData { + fn default() -> Self { + Self { layers: 1 } + } +} impl Value for SnowData { fn value(&self) -> usize { ((self.layers.value() - 1) * 1usize) @@ -9061,6 +11408,11 @@ impl CactusData { m } } +impl Default for CactusData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for CactusData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -9091,6 +11443,11 @@ impl SugarCaneData { m } } +impl Default for SugarCaneData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for SugarCaneData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -9121,6 +11478,11 @@ impl JukeboxData { m } } +impl Default for JukeboxData { + fn default() -> Self { + Self { has_record: false } + } +} impl Value for JukeboxData { fn value(&self) -> usize { (self.has_record.value() * 1usize) @@ -9137,61 +11499,72 @@ impl Value for JukeboxData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct OakFenceData { - pub south: bool, pub east: bool, + pub west: bool, pub waterlogged: bool, + pub south: bool, pub north: bool, - pub west: bool, } impl OakFenceData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - south: bool::from_snake_case(map.get("south")?)?, east: bool::from_snake_case(map.get("east")?)?, + west: bool::from_snake_case(map.get("west")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + south: bool::from_snake_case(map.get("south")?)?, north: bool::from_snake_case(map.get("north")?)?, - west: bool::from_snake_case(map.get("west")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("south".to_string(), self.south.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); m } } +impl Default for OakFenceData { + fn default() -> Self { + Self { + east: false, + west: false, + waterlogged: false, + south: false, + north: false, + } + } +} impl Value for OakFenceData { fn value(&self) -> usize { - (self.south.value() * 16usize) - + (self.east.value() * 8usize) + (self.east.value() * 16usize) + + (self.west.value() * 8usize) + (self.waterlogged.value() * 4usize) - + (self.north.value() * 2usize) - + (self.west.value() * 1usize) + + (self.south.value() * 2usize) + + (self.north.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let south = bool::from_value(val / 16usize).unwrap(); - val -= (south.value() - 0usize) * 16usize; - let east = bool::from_value(val / 8usize).unwrap(); - val -= (east.value() - 0usize) * 8usize; + let east = bool::from_value(val / 16usize).unwrap(); + val -= (east.value() - 0usize) * 16usize; + let west = bool::from_value(val / 8usize).unwrap(); + val -= (west.value() - 0usize) * 8usize; let waterlogged = bool::from_value(val / 4usize).unwrap(); val -= (waterlogged.value() - 0usize) * 4usize; - let north = bool::from_value(val / 2usize).unwrap(); - val -= (north.value() - 0usize) * 2usize; - let west = bool::from_value(val / 1usize).unwrap(); - val -= (west.value() - 0usize) * 1usize; + let south = bool::from_value(val / 2usize).unwrap(); + val -= (south.value() - 0usize) * 2usize; + let north = bool::from_value(val / 1usize).unwrap(); + val -= (north.value() - 0usize) * 1usize; Some(Self { - south, east, + west, waterlogged, + south, north, - west, }) } } @@ -9211,6 +11584,13 @@ impl NetherPortalData { m } } +impl Default for NetherPortalData { + fn default() -> Self { + Self { + axis: NetherPortalAxis::X, + } + } +} impl Value for NetherPortalData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -9241,6 +11621,13 @@ impl CarvedPumpkinData { m } } +impl Default for CarvedPumpkinData { + fn default() -> Self { + Self { + facing: CarvedPumpkinFacing::North, + } + } +} impl Value for CarvedPumpkinData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -9271,6 +11658,13 @@ impl JackOLanternData { m } } +impl Default for JackOLanternData { + fn default() -> Self { + Self { + facing: JackOLanternFacing::North, + } + } +} impl Value for JackOLanternData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -9301,6 +11695,11 @@ impl CakeData { m } } +impl Default for CakeData { + fn default() -> Self { + Self { bites: 0 } + } +} impl Value for CakeData { fn value(&self) -> usize { (self.bites.value() * 1usize) @@ -9317,33 +11716,43 @@ impl Value for CakeData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct RepeaterData { - pub facing: RepeaterFacing, pub powered: bool, + pub facing: RepeaterFacing, pub locked: bool, pub delay: i32, } impl RepeaterData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: RepeaterFacing::from_snake_case(map.get("facing")?)?, powered: bool::from_snake_case(map.get("powered")?)?, + facing: RepeaterFacing::from_snake_case(map.get("facing")?)?, locked: bool::from_snake_case(map.get("locked")?)?, delay: i32::from_snake_case(map.get("delay")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("locked".to_string(), self.locked.to_snake_case()); m.insert("delay".to_string(), self.delay.to_snake_case()); m } } +impl Default for RepeaterData { + fn default() -> Self { + Self { + powered: false, + facing: RepeaterFacing::North, + locked: false, + delay: 1, + } + } +} impl Value for RepeaterData { fn value(&self) -> usize { - (self.facing.value() * 16usize) - + (self.powered.value() * 8usize) + (self.powered.value() * 32usize) + + (self.facing.value() * 8usize) + (self.locked.value() * 4usize) + ((self.delay.value() - 1) * 1usize) } @@ -9352,17 +11761,17 @@ impl Value for RepeaterData { if val >= 64usize { return None; } - let facing = RepeaterFacing::from_value(val / 16usize).unwrap(); - val -= (facing.value() - 0usize) * 16usize; - let powered = bool::from_value(val / 8usize).unwrap(); - val -= (powered.value() - 0usize) * 8usize; + let powered = bool::from_value(val / 32usize).unwrap(); + val -= (powered.value() - 0usize) * 32usize; + let facing = RepeaterFacing::from_value(val / 8usize).unwrap(); + val -= (facing.value() - 0usize) * 8usize; let locked = bool::from_value(val / 4usize).unwrap(); val -= (locked.value() - 0usize) * 4usize; let delay = i32::from_value(val / 1usize).unwrap() + 1i32; val -= (delay.value() - 1usize) * 1usize; Some(Self { - facing, powered, + facing, locked, delay, }) @@ -9370,98 +11779,120 @@ impl Value for RepeaterData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct OakTrapdoorData { - pub powered: bool, pub open: bool, - pub facing: OakTrapdoorFacing, - pub half: OakTrapdoorHalf, pub waterlogged: bool, + pub half: OakTrapdoorHalf, + pub facing: OakTrapdoorFacing, + pub powered: bool, } impl OakTrapdoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - powered: bool::from_snake_case(map.get("powered")?)?, open: bool::from_snake_case(map.get("open")?)?, - facing: OakTrapdoorFacing::from_snake_case(map.get("facing")?)?, - half: OakTrapdoorHalf::from_snake_case(map.get("half")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + half: OakTrapdoorHalf::from_snake_case(map.get("half")?)?, + facing: OakTrapdoorFacing::from_snake_case(map.get("facing")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for OakTrapdoorData { + fn default() -> Self { + Self { + open: false, + waterlogged: false, + half: OakTrapdoorHalf::Bottom, + facing: OakTrapdoorFacing::North, + powered: false, + } + } +} impl Value for OakTrapdoorData { fn value(&self) -> usize { - (self.powered.value() * 32usize) - + (self.open.value() * 16usize) - + (self.facing.value() * 4usize) - + (self.half.value() * 2usize) - + (self.waterlogged.value() * 1usize) + (self.open.value() * 32usize) + + (self.waterlogged.value() * 16usize) + + (self.half.value() * 8usize) + + (self.facing.value() * 2usize) + + (self.powered.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 64usize { return None; } - let powered = bool::from_value(val / 32usize).unwrap(); - val -= (powered.value() - 0usize) * 32usize; - let open = bool::from_value(val / 16usize).unwrap(); - val -= (open.value() - 0usize) * 16usize; - let facing = OakTrapdoorFacing::from_value(val / 4usize).unwrap(); - val -= (facing.value() - 0usize) * 4usize; - let half = OakTrapdoorHalf::from_value(val / 2usize).unwrap(); - val -= (half.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let open = bool::from_value(val / 32usize).unwrap(); + val -= (open.value() - 0usize) * 32usize; + let waterlogged = bool::from_value(val / 16usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 16usize; + let half = OakTrapdoorHalf::from_value(val / 8usize).unwrap(); + val -= (half.value() - 0usize) * 8usize; + let facing = OakTrapdoorFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let powered = bool::from_value(val / 1usize).unwrap(); + val -= (powered.value() - 0usize) * 1usize; Some(Self { - powered, open, - facing, - half, waterlogged, + half, + facing, + powered, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct SpruceTrapdoorData { pub facing: SpruceTrapdoorFacing, - pub open: bool, - pub half: SpruceTrapdoorHalf, pub powered: bool, + pub half: SpruceTrapdoorHalf, + pub open: bool, pub waterlogged: bool, } impl SpruceTrapdoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { facing: SpruceTrapdoorFacing::from_snake_case(map.get("facing")?)?, - open: bool::from_snake_case(map.get("open")?)?, - half: SpruceTrapdoorHalf::from_snake_case(map.get("half")?)?, powered: bool::from_snake_case(map.get("powered")?)?, + half: SpruceTrapdoorHalf::from_snake_case(map.get("half")?)?, + open: bool::from_snake_case(map.get("open")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("open".to_string(), self.open.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("open".to_string(), self.open.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for SpruceTrapdoorData { + fn default() -> Self { + Self { + facing: SpruceTrapdoorFacing::North, + powered: false, + half: SpruceTrapdoorHalf::Bottom, + open: false, + waterlogged: false, + } + } +} impl Value for SpruceTrapdoorData { fn value(&self) -> usize { (self.facing.value() * 16usize) - + (self.open.value() * 8usize) + + (self.powered.value() * 8usize) + (self.half.value() * 4usize) - + (self.powered.value() * 2usize) + + (self.open.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] @@ -9471,19 +11902,19 @@ impl Value for SpruceTrapdoorData { } let facing = SpruceTrapdoorFacing::from_value(val / 16usize).unwrap(); val -= (facing.value() - 0usize) * 16usize; - let open = bool::from_value(val / 8usize).unwrap(); - val -= (open.value() - 0usize) * 8usize; + let powered = bool::from_value(val / 8usize).unwrap(); + val -= (powered.value() - 0usize) * 8usize; let half = SpruceTrapdoorHalf::from_value(val / 4usize).unwrap(); val -= (half.value() - 0usize) * 4usize; - let powered = bool::from_value(val / 2usize).unwrap(); - val -= (powered.value() - 0usize) * 2usize; + let open = bool::from_value(val / 2usize).unwrap(); + val -= (open.value() - 0usize) * 2usize; let waterlogged = bool::from_value(val / 1usize).unwrap(); val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { facing, - open, - half, powered, + half, + open, waterlogged, }) } @@ -9491,38 +11922,49 @@ impl Value for SpruceTrapdoorData { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BirchTrapdoorData { pub waterlogged: bool, - pub powered: bool, - pub open: bool, pub half: BirchTrapdoorHalf, + pub powered: bool, pub facing: BirchTrapdoorFacing, + pub open: bool, } impl BirchTrapdoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - powered: bool::from_snake_case(map.get("powered")?)?, - open: bool::from_snake_case(map.get("open")?)?, half: BirchTrapdoorHalf::from_snake_case(map.get("half")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, facing: BirchTrapdoorFacing::from_snake_case(map.get("facing")?)?, + open: bool::from_snake_case(map.get("open")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("powered".to_string(), self.powered.to_snake_case()); - m.insert("open".to_string(), self.open.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("open".to_string(), self.open.to_snake_case()); m } } +impl Default for BirchTrapdoorData { + fn default() -> Self { + Self { + waterlogged: false, + half: BirchTrapdoorHalf::Bottom, + powered: false, + facing: BirchTrapdoorFacing::North, + open: false, + } + } +} impl Value for BirchTrapdoorData { fn value(&self) -> usize { (self.waterlogged.value() * 32usize) - + (self.powered.value() * 16usize) - + (self.open.value() * 8usize) - + (self.half.value() * 4usize) - + (self.facing.value() * 1usize) + + (self.half.value() * 16usize) + + (self.powered.value() * 8usize) + + (self.facing.value() * 2usize) + + (self.open.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -9531,20 +11973,20 @@ impl Value for BirchTrapdoorData { } let waterlogged = bool::from_value(val / 32usize).unwrap(); val -= (waterlogged.value() - 0usize) * 32usize; - let powered = bool::from_value(val / 16usize).unwrap(); - val -= (powered.value() - 0usize) * 16usize; - let open = bool::from_value(val / 8usize).unwrap(); - val -= (open.value() - 0usize) * 8usize; - let half = BirchTrapdoorHalf::from_value(val / 4usize).unwrap(); - val -= (half.value() - 0usize) * 4usize; - let facing = BirchTrapdoorFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let half = BirchTrapdoorHalf::from_value(val / 16usize).unwrap(); + val -= (half.value() - 0usize) * 16usize; + let powered = bool::from_value(val / 8usize).unwrap(); + val -= (powered.value() - 0usize) * 8usize; + let facing = BirchTrapdoorFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let open = bool::from_value(val / 1usize).unwrap(); + val -= (open.value() - 0usize) * 1usize; Some(Self { waterlogged, - powered, - open, half, + powered, facing, + open, }) } } @@ -9552,37 +11994,48 @@ impl Value for BirchTrapdoorData { pub struct JungleTrapdoorData { pub powered: bool, pub open: bool, - pub half: JungleTrapdoorHalf, pub waterlogged: bool, pub facing: JungleTrapdoorFacing, + pub half: JungleTrapdoorHalf, } impl JungleTrapdoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { powered: bool::from_snake_case(map.get("powered")?)?, open: bool::from_snake_case(map.get("open")?)?, - half: JungleTrapdoorHalf::from_snake_case(map.get("half")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, facing: JungleTrapdoorFacing::from_snake_case(map.get("facing")?)?, + half: JungleTrapdoorHalf::from_snake_case(map.get("half")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); m } } +impl Default for JungleTrapdoorData { + fn default() -> Self { + Self { + powered: false, + open: false, + waterlogged: false, + facing: JungleTrapdoorFacing::North, + half: JungleTrapdoorHalf::Bottom, + } + } +} impl Value for JungleTrapdoorData { fn value(&self) -> usize { (self.powered.value() * 32usize) + (self.open.value() * 16usize) - + (self.half.value() * 8usize) - + (self.waterlogged.value() * 4usize) - + (self.facing.value() * 1usize) + + (self.waterlogged.value() * 8usize) + + (self.facing.value() * 2usize) + + (self.half.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -9593,313 +12046,371 @@ impl Value for JungleTrapdoorData { val -= (powered.value() - 0usize) * 32usize; let open = bool::from_value(val / 16usize).unwrap(); val -= (open.value() - 0usize) * 16usize; - let half = JungleTrapdoorHalf::from_value(val / 8usize).unwrap(); - val -= (half.value() - 0usize) * 8usize; - let waterlogged = bool::from_value(val / 4usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 4usize; - let facing = JungleTrapdoorFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let waterlogged = bool::from_value(val / 8usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 8usize; + let facing = JungleTrapdoorFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let half = JungleTrapdoorHalf::from_value(val / 1usize).unwrap(); + val -= (half.value() - 0usize) * 1usize; Some(Self { powered, open, - half, waterlogged, facing, + half, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct AcaciaTrapdoorData { - pub open: bool, - pub powered: bool, pub waterlogged: bool, - pub facing: AcaciaTrapdoorFacing, + pub open: bool, pub half: AcaciaTrapdoorHalf, + pub facing: AcaciaTrapdoorFacing, + pub powered: bool, } impl AcaciaTrapdoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - open: bool::from_snake_case(map.get("open")?)?, - powered: bool::from_snake_case(map.get("powered")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - facing: AcaciaTrapdoorFacing::from_snake_case(map.get("facing")?)?, + open: bool::from_snake_case(map.get("open")?)?, half: AcaciaTrapdoorHalf::from_snake_case(map.get("half")?)?, + facing: AcaciaTrapdoorFacing::from_snake_case(map.get("facing")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("open".to_string(), self.open.to_snake_case()); - m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("open".to_string(), self.open.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for AcaciaTrapdoorData { + fn default() -> Self { + Self { + waterlogged: false, + open: false, + half: AcaciaTrapdoorHalf::Bottom, + facing: AcaciaTrapdoorFacing::North, + powered: false, + } + } +} impl Value for AcaciaTrapdoorData { fn value(&self) -> usize { - (self.open.value() * 32usize) - + (self.powered.value() * 16usize) - + (self.waterlogged.value() * 8usize) + (self.waterlogged.value() * 32usize) + + (self.open.value() * 16usize) + + (self.half.value() * 8usize) + (self.facing.value() * 2usize) - + (self.half.value() * 1usize) + + (self.powered.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 64usize { return None; } - let open = bool::from_value(val / 32usize).unwrap(); - val -= (open.value() - 0usize) * 32usize; - let powered = bool::from_value(val / 16usize).unwrap(); - val -= (powered.value() - 0usize) * 16usize; - let waterlogged = bool::from_value(val / 8usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 8usize; + let waterlogged = bool::from_value(val / 32usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 32usize; + let open = bool::from_value(val / 16usize).unwrap(); + val -= (open.value() - 0usize) * 16usize; + let half = AcaciaTrapdoorHalf::from_value(val / 8usize).unwrap(); + val -= (half.value() - 0usize) * 8usize; let facing = AcaciaTrapdoorFacing::from_value(val / 2usize).unwrap(); val -= (facing.value() - 0usize) * 2usize; - let half = AcaciaTrapdoorHalf::from_value(val / 1usize).unwrap(); - val -= (half.value() - 0usize) * 1usize; + let powered = bool::from_value(val / 1usize).unwrap(); + val -= (powered.value() - 0usize) * 1usize; Some(Self { - open, - powered, waterlogged, - facing, + open, half, + facing, + powered, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DarkOakTrapdoorData { - pub powered: bool, - pub waterlogged: bool, pub facing: DarkOakTrapdoorFacing, - pub half: DarkOakTrapdoorHalf, + pub waterlogged: bool, pub open: bool, + pub powered: bool, + pub half: DarkOakTrapdoorHalf, } impl DarkOakTrapdoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - powered: bool::from_snake_case(map.get("powered")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, facing: DarkOakTrapdoorFacing::from_snake_case(map.get("facing")?)?, - half: DarkOakTrapdoorHalf::from_snake_case(map.get("half")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, open: bool::from_snake_case(map.get("open")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, + half: DarkOakTrapdoorHalf::from_snake_case(map.get("half")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("powered".to_string(), self.powered.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); m } } +impl Default for DarkOakTrapdoorData { + fn default() -> Self { + Self { + facing: DarkOakTrapdoorFacing::North, + waterlogged: false, + open: false, + powered: false, + half: DarkOakTrapdoorHalf::Bottom, + } + } +} impl Value for DarkOakTrapdoorData { fn value(&self) -> usize { - (self.powered.value() * 32usize) - + (self.waterlogged.value() * 16usize) - + (self.facing.value() * 4usize) - + (self.half.value() * 2usize) - + (self.open.value() * 1usize) + (self.facing.value() * 16usize) + + (self.waterlogged.value() * 8usize) + + (self.open.value() * 4usize) + + (self.powered.value() * 2usize) + + (self.half.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 64usize { return None; } - let powered = bool::from_value(val / 32usize).unwrap(); - val -= (powered.value() - 0usize) * 32usize; - let waterlogged = bool::from_value(val / 16usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 16usize; - let facing = DarkOakTrapdoorFacing::from_value(val / 4usize).unwrap(); - val -= (facing.value() - 0usize) * 4usize; - let half = DarkOakTrapdoorHalf::from_value(val / 2usize).unwrap(); - val -= (half.value() - 0usize) * 2usize; - let open = bool::from_value(val / 1usize).unwrap(); - val -= (open.value() - 0usize) * 1usize; + let facing = DarkOakTrapdoorFacing::from_value(val / 16usize).unwrap(); + val -= (facing.value() - 0usize) * 16usize; + let waterlogged = bool::from_value(val / 8usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 8usize; + let open = bool::from_value(val / 4usize).unwrap(); + val -= (open.value() - 0usize) * 4usize; + let powered = bool::from_value(val / 2usize).unwrap(); + val -= (powered.value() - 0usize) * 2usize; + let half = DarkOakTrapdoorHalf::from_value(val / 1usize).unwrap(); + val -= (half.value() - 0usize) * 1usize; Some(Self { - powered, - waterlogged, facing, - half, + waterlogged, open, + powered, + half, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BrownMushroomBlockData { - pub down: bool, pub east: bool, pub north: bool, - pub west: bool, - pub south: bool, pub up: bool, + pub south: bool, + pub down: bool, + pub west: bool, } impl BrownMushroomBlockData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - down: bool::from_snake_case(map.get("down")?)?, east: bool::from_snake_case(map.get("east")?)?, north: bool::from_snake_case(map.get("north")?)?, - west: bool::from_snake_case(map.get("west")?)?, - south: bool::from_snake_case(map.get("south")?)?, up: bool::from_snake_case(map.get("up")?)?, + south: bool::from_snake_case(map.get("south")?)?, + down: bool::from_snake_case(map.get("down")?)?, + west: bool::from_snake_case(map.get("west")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("down".to_string(), self.down.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); m.insert("up".to_string(), self.up.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); + m.insert("down".to_string(), self.down.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); m } } +impl Default for BrownMushroomBlockData { + fn default() -> Self { + Self { + east: true, + north: true, + up: true, + south: true, + down: true, + west: true, + } + } +} impl Value for BrownMushroomBlockData { fn value(&self) -> usize { - (self.down.value() * 32usize) - + (self.east.value() * 16usize) - + (self.north.value() * 8usize) - + (self.west.value() * 4usize) - + (self.south.value() * 2usize) - + (self.up.value() * 1usize) + (self.east.value() * 32usize) + + (self.north.value() * 16usize) + + (self.up.value() * 8usize) + + (self.south.value() * 4usize) + + (self.down.value() * 2usize) + + (self.west.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 64usize { return None; } - let down = bool::from_value(val / 32usize).unwrap(); - val -= (down.value() - 0usize) * 32usize; - let east = bool::from_value(val / 16usize).unwrap(); - val -= (east.value() - 0usize) * 16usize; - let north = bool::from_value(val / 8usize).unwrap(); - val -= (north.value() - 0usize) * 8usize; - let west = bool::from_value(val / 4usize).unwrap(); - val -= (west.value() - 0usize) * 4usize; - let south = bool::from_value(val / 2usize).unwrap(); - val -= (south.value() - 0usize) * 2usize; - let up = bool::from_value(val / 1usize).unwrap(); - val -= (up.value() - 0usize) * 1usize; + let east = bool::from_value(val / 32usize).unwrap(); + val -= (east.value() - 0usize) * 32usize; + let north = bool::from_value(val / 16usize).unwrap(); + val -= (north.value() - 0usize) * 16usize; + let up = bool::from_value(val / 8usize).unwrap(); + val -= (up.value() - 0usize) * 8usize; + let south = bool::from_value(val / 4usize).unwrap(); + val -= (south.value() - 0usize) * 4usize; + let down = bool::from_value(val / 2usize).unwrap(); + val -= (down.value() - 0usize) * 2usize; + let west = bool::from_value(val / 1usize).unwrap(); + val -= (west.value() - 0usize) * 1usize; Some(Self { - down, east, north, - west, - south, up, + south, + down, + west, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct RedMushroomBlockData { - pub up: bool, + pub south: bool, pub down: bool, + pub east: bool, + pub up: bool, pub north: bool, pub west: bool, - pub east: bool, - pub south: bool, } impl RedMushroomBlockData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - up: bool::from_snake_case(map.get("up")?)?, + south: bool::from_snake_case(map.get("south")?)?, down: bool::from_snake_case(map.get("down")?)?, + east: bool::from_snake_case(map.get("east")?)?, + up: bool::from_snake_case(map.get("up")?)?, north: bool::from_snake_case(map.get("north")?)?, west: bool::from_snake_case(map.get("west")?)?, - east: bool::from_snake_case(map.get("east")?)?, - south: bool::from_snake_case(map.get("south")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("up".to_string(), self.up.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); m.insert("down".to_string(), self.down.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("up".to_string(), self.up.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); m } } +impl Default for RedMushroomBlockData { + fn default() -> Self { + Self { + south: true, + down: true, + east: true, + up: true, + north: true, + west: true, + } + } +} impl Value for RedMushroomBlockData { fn value(&self) -> usize { - (self.up.value() * 32usize) + (self.south.value() * 32usize) + (self.down.value() * 16usize) - + (self.north.value() * 8usize) - + (self.west.value() * 4usize) - + (self.east.value() * 2usize) - + (self.south.value() * 1usize) + + (self.east.value() * 8usize) + + (self.up.value() * 4usize) + + (self.north.value() * 2usize) + + (self.west.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 64usize { return None; } - let up = bool::from_value(val / 32usize).unwrap(); - val -= (up.value() - 0usize) * 32usize; + let south = bool::from_value(val / 32usize).unwrap(); + val -= (south.value() - 0usize) * 32usize; let down = bool::from_value(val / 16usize).unwrap(); val -= (down.value() - 0usize) * 16usize; - let north = bool::from_value(val / 8usize).unwrap(); - val -= (north.value() - 0usize) * 8usize; - let west = bool::from_value(val / 4usize).unwrap(); - val -= (west.value() - 0usize) * 4usize; - let east = bool::from_value(val / 2usize).unwrap(); - val -= (east.value() - 0usize) * 2usize; - let south = bool::from_value(val / 1usize).unwrap(); - val -= (south.value() - 0usize) * 1usize; + let east = bool::from_value(val / 8usize).unwrap(); + val -= (east.value() - 0usize) * 8usize; + let up = bool::from_value(val / 4usize).unwrap(); + val -= (up.value() - 0usize) * 4usize; + let north = bool::from_value(val / 2usize).unwrap(); + val -= (north.value() - 0usize) * 2usize; + let west = bool::from_value(val / 1usize).unwrap(); + val -= (west.value() - 0usize) * 1usize; Some(Self { - up, + south, down, + east, + up, north, west, - east, - south, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct MushroomStemData { - pub south: bool, - pub east: bool, pub north: bool, - pub down: bool, + pub east: bool, pub up: bool, + pub south: bool, + pub down: bool, pub west: bool, } impl MushroomStemData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - south: bool::from_snake_case(map.get("south")?)?, - east: bool::from_snake_case(map.get("east")?)?, north: bool::from_snake_case(map.get("north")?)?, - down: bool::from_snake_case(map.get("down")?)?, + east: bool::from_snake_case(map.get("east")?)?, up: bool::from_snake_case(map.get("up")?)?, + south: bool::from_snake_case(map.get("south")?)?, + down: bool::from_snake_case(map.get("down")?)?, west: bool::from_snake_case(map.get("west")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("down".to_string(), self.down.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m.insert("up".to_string(), self.up.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); + m.insert("down".to_string(), self.down.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); m } } +impl Default for MushroomStemData { + fn default() -> Self { + Self { + north: true, + east: true, + up: true, + south: true, + down: true, + west: true, + } + } +} impl Value for MushroomStemData { fn value(&self) -> usize { - (self.south.value() * 32usize) + (self.north.value() * 32usize) + (self.east.value() * 16usize) - + (self.north.value() * 8usize) - + (self.down.value() * 4usize) - + (self.up.value() * 2usize) + + (self.up.value() * 8usize) + + (self.south.value() * 4usize) + + (self.down.value() * 2usize) + (self.west.value() * 1usize) } #[allow(warnings)] @@ -9907,145 +12418,167 @@ impl Value for MushroomStemData { if val >= 64usize { return None; } - let south = bool::from_value(val / 32usize).unwrap(); - val -= (south.value() - 0usize) * 32usize; + let north = bool::from_value(val / 32usize).unwrap(); + val -= (north.value() - 0usize) * 32usize; let east = bool::from_value(val / 16usize).unwrap(); val -= (east.value() - 0usize) * 16usize; - let north = bool::from_value(val / 8usize).unwrap(); - val -= (north.value() - 0usize) * 8usize; - let down = bool::from_value(val / 4usize).unwrap(); - val -= (down.value() - 0usize) * 4usize; - let up = bool::from_value(val / 2usize).unwrap(); - val -= (up.value() - 0usize) * 2usize; + let up = bool::from_value(val / 8usize).unwrap(); + val -= (up.value() - 0usize) * 8usize; + let south = bool::from_value(val / 4usize).unwrap(); + val -= (south.value() - 0usize) * 4usize; + let down = bool::from_value(val / 2usize).unwrap(); + val -= (down.value() - 0usize) * 2usize; let west = bool::from_value(val / 1usize).unwrap(); val -= (west.value() - 0usize) * 1usize; Some(Self { - south, - east, north, - down, + east, up, + south, + down, west, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct IronBarsData { - pub west: bool, pub east: bool, - pub north: bool, pub south: bool, pub waterlogged: bool, + pub west: bool, + pub north: bool, } impl IronBarsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - west: bool::from_snake_case(map.get("west")?)?, east: bool::from_snake_case(map.get("east")?)?, - north: bool::from_snake_case(map.get("north")?)?, south: bool::from_snake_case(map.get("south")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + west: bool::from_snake_case(map.get("west")?)?, + north: bool::from_snake_case(map.get("north")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("west".to_string(), self.west.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("north".to_string(), self.north.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("north".to_string(), self.north.to_snake_case()); m } } +impl Default for IronBarsData { + fn default() -> Self { + Self { + east: false, + south: false, + waterlogged: false, + west: false, + north: false, + } + } +} impl Value for IronBarsData { fn value(&self) -> usize { - (self.west.value() * 16usize) - + (self.east.value() * 8usize) - + (self.north.value() * 4usize) - + (self.south.value() * 2usize) - + (self.waterlogged.value() * 1usize) + (self.east.value() * 16usize) + + (self.south.value() * 8usize) + + (self.waterlogged.value() * 4usize) + + (self.west.value() * 2usize) + + (self.north.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let west = bool::from_value(val / 16usize).unwrap(); - val -= (west.value() - 0usize) * 16usize; - let east = bool::from_value(val / 8usize).unwrap(); - val -= (east.value() - 0usize) * 8usize; - let north = bool::from_value(val / 4usize).unwrap(); - val -= (north.value() - 0usize) * 4usize; - let south = bool::from_value(val / 2usize).unwrap(); - val -= (south.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let east = bool::from_value(val / 16usize).unwrap(); + val -= (east.value() - 0usize) * 16usize; + let south = bool::from_value(val / 8usize).unwrap(); + val -= (south.value() - 0usize) * 8usize; + let waterlogged = bool::from_value(val / 4usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 4usize; + let west = bool::from_value(val / 2usize).unwrap(); + val -= (west.value() - 0usize) * 2usize; + let north = bool::from_value(val / 1usize).unwrap(); + val -= (north.value() - 0usize) * 1usize; Some(Self { - west, east, - north, south, waterlogged, + west, + north, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct GlassPaneData { + pub south: bool, + pub east: bool, pub north: bool, - pub waterlogged: bool, pub west: bool, - pub east: bool, - pub south: bool, + pub waterlogged: bool, } impl GlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + south: bool::from_snake_case(map.get("south")?)?, + east: bool::from_snake_case(map.get("east")?)?, north: bool::from_snake_case(map.get("north")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, west: bool::from_snake_case(map.get("west")?)?, - east: bool::from_snake_case(map.get("east")?)?, - south: bool::from_snake_case(map.get("south")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("south".to_string(), self.south.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for GlassPaneData { + fn default() -> Self { + Self { + south: false, + east: false, + north: false, + west: false, + waterlogged: false, + } + } +} impl Value for GlassPaneData { fn value(&self) -> usize { - (self.north.value() * 16usize) - + (self.waterlogged.value() * 8usize) - + (self.west.value() * 4usize) - + (self.east.value() * 2usize) - + (self.south.value() * 1usize) + (self.south.value() * 16usize) + + (self.east.value() * 8usize) + + (self.north.value() * 4usize) + + (self.west.value() * 2usize) + + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let north = bool::from_value(val / 16usize).unwrap(); - val -= (north.value() - 0usize) * 16usize; - let waterlogged = bool::from_value(val / 8usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 8usize; - let west = bool::from_value(val / 4usize).unwrap(); - val -= (west.value() - 0usize) * 4usize; - let east = bool::from_value(val / 2usize).unwrap(); - val -= (east.value() - 0usize) * 2usize; - let south = bool::from_value(val / 1usize).unwrap(); - val -= (south.value() - 0usize) * 1usize; + let south = bool::from_value(val / 16usize).unwrap(); + val -= (south.value() - 0usize) * 16usize; + let east = bool::from_value(val / 8usize).unwrap(); + val -= (east.value() - 0usize) * 8usize; + let north = bool::from_value(val / 4usize).unwrap(); + val -= (north.value() - 0usize) * 4usize; + let west = bool::from_value(val / 2usize).unwrap(); + val -= (west.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { + south, + east, north, - waterlogged, west, - east, - south, + waterlogged, }) } } @@ -10065,6 +12598,13 @@ impl AttachedPumpkinStemData { m } } +impl Default for AttachedPumpkinStemData { + fn default() -> Self { + Self { + facing: AttachedPumpkinStemFacing::North, + } + } +} impl Value for AttachedPumpkinStemData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -10095,6 +12635,13 @@ impl AttachedMelonStemData { m } } +impl Default for AttachedMelonStemData { + fn default() -> Self { + Self { + facing: AttachedMelonStemFacing::North, + } + } +} impl Value for AttachedMelonStemData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -10125,6 +12672,11 @@ impl PumpkinStemData { m } } +impl Default for PumpkinStemData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for PumpkinStemData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -10155,6 +12707,11 @@ impl MelonStemData { m } } +impl Default for MelonStemData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for MelonStemData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -10173,37 +12730,48 @@ impl Value for MelonStemData { pub struct VineData { pub east: bool, pub north: bool, + pub south: bool, pub up: bool, pub west: bool, - pub south: bool, } impl VineData { pub fn from_map(map: &HashMap) -> Option { Some(Self { east: bool::from_snake_case(map.get("east")?)?, north: bool::from_snake_case(map.get("north")?)?, + south: bool::from_snake_case(map.get("south")?)?, up: bool::from_snake_case(map.get("up")?)?, west: bool::from_snake_case(map.get("west")?)?, - south: bool::from_snake_case(map.get("south")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("east".to_string(), self.east.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); m.insert("up".to_string(), self.up.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); m } } +impl Default for VineData { + fn default() -> Self { + Self { + east: false, + north: false, + south: false, + up: false, + west: false, + } + } +} impl Value for VineData { fn value(&self) -> usize { (self.east.value() * 16usize) + (self.north.value() * 8usize) - + (self.up.value() * 4usize) - + (self.west.value() * 2usize) - + (self.south.value() * 1usize) + + (self.south.value() * 4usize) + + (self.up.value() * 2usize) + + (self.west.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -10214,71 +12782,81 @@ impl Value for VineData { val -= (east.value() - 0usize) * 16usize; let north = bool::from_value(val / 8usize).unwrap(); val -= (north.value() - 0usize) * 8usize; - let up = bool::from_value(val / 4usize).unwrap(); - val -= (up.value() - 0usize) * 4usize; - let west = bool::from_value(val / 2usize).unwrap(); - val -= (west.value() - 0usize) * 2usize; - let south = bool::from_value(val / 1usize).unwrap(); - val -= (south.value() - 0usize) * 1usize; + let south = bool::from_value(val / 4usize).unwrap(); + val -= (south.value() - 0usize) * 4usize; + let up = bool::from_value(val / 2usize).unwrap(); + val -= (up.value() - 0usize) * 2usize; + let west = bool::from_value(val / 1usize).unwrap(); + val -= (west.value() - 0usize) * 1usize; Some(Self { east, north, + south, up, west, - south, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct OakFenceGateData { - pub open: bool, - pub in_wall: bool, pub powered: bool, pub facing: OakFenceGateFacing, + pub in_wall: bool, + pub open: bool, } impl OakFenceGateData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - open: bool::from_snake_case(map.get("open")?)?, - in_wall: bool::from_snake_case(map.get("in_wall")?)?, powered: bool::from_snake_case(map.get("powered")?)?, facing: OakFenceGateFacing::from_snake_case(map.get("facing")?)?, + in_wall: bool::from_snake_case(map.get("in_wall")?)?, + open: bool::from_snake_case(map.get("open")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("open".to_string(), self.open.to_snake_case()); - m.insert("in_wall".to_string(), self.in_wall.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("in_wall".to_string(), self.in_wall.to_snake_case()); + m.insert("open".to_string(), self.open.to_snake_case()); m } } +impl Default for OakFenceGateData { + fn default() -> Self { + Self { + powered: false, + facing: OakFenceGateFacing::North, + in_wall: false, + open: false, + } + } +} impl Value for OakFenceGateData { fn value(&self) -> usize { - (self.open.value() * 16usize) - + (self.in_wall.value() * 8usize) - + (self.powered.value() * 4usize) - + (self.facing.value() * 1usize) + (self.powered.value() * 16usize) + + (self.facing.value() * 4usize) + + (self.in_wall.value() * 2usize) + + (self.open.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let open = bool::from_value(val / 16usize).unwrap(); - val -= (open.value() - 0usize) * 16usize; - let in_wall = bool::from_value(val / 8usize).unwrap(); - val -= (in_wall.value() - 0usize) * 8usize; - let powered = bool::from_value(val / 4usize).unwrap(); - val -= (powered.value() - 0usize) * 4usize; - let facing = OakFenceGateFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let powered = bool::from_value(val / 16usize).unwrap(); + val -= (powered.value() - 0usize) * 16usize; + let facing = OakFenceGateFacing::from_value(val / 4usize).unwrap(); + val -= (facing.value() - 0usize) * 4usize; + let in_wall = bool::from_value(val / 2usize).unwrap(); + val -= (in_wall.value() - 0usize) * 2usize; + let open = bool::from_value(val / 1usize).unwrap(); + val -= (open.value() - 0usize) * 1usize; Some(Self { - open, - in_wall, powered, facing, + in_wall, + open, }) } } @@ -10307,6 +12885,16 @@ impl BrickStairsData { m } } +impl Default for BrickStairsData { + fn default() -> Self { + Self { + shape: BrickStairsShape::Straight, + half: BrickStairsHalf::Bottom, + facing: BrickStairsFacing::North, + waterlogged: false, + } + } +} impl Value for BrickStairsData { fn value(&self) -> usize { (self.shape.value() * 16usize) @@ -10337,34 +12925,44 @@ impl Value for BrickStairsData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct StoneBrickStairsData { + pub waterlogged: bool, pub facing: StoneBrickStairsFacing, pub half: StoneBrickStairsHalf, - pub waterlogged: bool, pub shape: StoneBrickStairsShape, } impl StoneBrickStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, facing: StoneBrickStairsFacing::from_snake_case(map.get("facing")?)?, half: StoneBrickStairsHalf::from_snake_case(map.get("half")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, shape: StoneBrickStairsShape::from_snake_case(map.get("shape")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); m } } +impl Default for StoneBrickStairsData { + fn default() -> Self { + Self { + waterlogged: false, + facing: StoneBrickStairsFacing::North, + half: StoneBrickStairsHalf::Bottom, + shape: StoneBrickStairsShape::Straight, + } + } +} impl Value for StoneBrickStairsData { fn value(&self) -> usize { - (self.facing.value() * 20usize) - + (self.half.value() * 10usize) - + (self.waterlogged.value() * 5usize) + (self.waterlogged.value() * 40usize) + + (self.facing.value() * 10usize) + + (self.half.value() * 5usize) + (self.shape.value() * 1usize) } #[allow(warnings)] @@ -10372,18 +12970,18 @@ impl Value for StoneBrickStairsData { if val >= 80usize { return None; } - let facing = StoneBrickStairsFacing::from_value(val / 20usize).unwrap(); - val -= (facing.value() - 0usize) * 20usize; - let half = StoneBrickStairsHalf::from_value(val / 10usize).unwrap(); - val -= (half.value() - 0usize) * 10usize; - let waterlogged = bool::from_value(val / 5usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 5usize; + let waterlogged = bool::from_value(val / 40usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 40usize; + let facing = StoneBrickStairsFacing::from_value(val / 10usize).unwrap(); + val -= (facing.value() - 0usize) * 10usize; + let half = StoneBrickStairsHalf::from_value(val / 5usize).unwrap(); + val -= (half.value() - 0usize) * 5usize; let shape = StoneBrickStairsShape::from_value(val / 1usize).unwrap(); val -= (shape.value() - 0usize) * 1usize; Some(Self { + waterlogged, facing, half, - waterlogged, shape, }) } @@ -10404,6 +13002,11 @@ impl MyceliumData { m } } +impl Default for MyceliumData { + fn default() -> Self { + Self { snowy: false } + } +} impl Value for MyceliumData { fn value(&self) -> usize { (self.snowy.value() * 1usize) @@ -10420,94 +13023,115 @@ impl Value for MyceliumData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct NetherBrickFenceData { - pub south: bool, pub west: bool, - pub east: bool, - pub waterlogged: bool, + pub south: bool, pub north: bool, + pub waterlogged: bool, + pub east: bool, } impl NetherBrickFenceData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - south: bool::from_snake_case(map.get("south")?)?, west: bool::from_snake_case(map.get("west")?)?, - east: bool::from_snake_case(map.get("east")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + south: bool::from_snake_case(map.get("south")?)?, north: bool::from_snake_case(map.get("north")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + east: bool::from_snake_case(map.get("east")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("south".to_string(), self.south.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m } } +impl Default for NetherBrickFenceData { + fn default() -> Self { + Self { + west: false, + south: false, + north: false, + waterlogged: false, + east: false, + } + } +} impl Value for NetherBrickFenceData { fn value(&self) -> usize { - (self.south.value() * 16usize) - + (self.west.value() * 8usize) - + (self.east.value() * 4usize) + (self.west.value() * 16usize) + + (self.south.value() * 8usize) + + (self.north.value() * 4usize) + (self.waterlogged.value() * 2usize) - + (self.north.value() * 1usize) + + (self.east.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let south = bool::from_value(val / 16usize).unwrap(); - val -= (south.value() - 0usize) * 16usize; - let west = bool::from_value(val / 8usize).unwrap(); - val -= (west.value() - 0usize) * 8usize; - let east = bool::from_value(val / 4usize).unwrap(); - val -= (east.value() - 0usize) * 4usize; + let west = bool::from_value(val / 16usize).unwrap(); + val -= (west.value() - 0usize) * 16usize; + let south = bool::from_value(val / 8usize).unwrap(); + val -= (south.value() - 0usize) * 8usize; + let north = bool::from_value(val / 4usize).unwrap(); + val -= (north.value() - 0usize) * 4usize; let waterlogged = bool::from_value(val / 2usize).unwrap(); val -= (waterlogged.value() - 0usize) * 2usize; - let north = bool::from_value(val / 1usize).unwrap(); - val -= (north.value() - 0usize) * 1usize; + let east = bool::from_value(val / 1usize).unwrap(); + val -= (east.value() - 0usize) * 1usize; Some(Self { - south, west, - east, - waterlogged, + south, north, + waterlogged, + east, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct NetherBrickStairsData { - pub facing: NetherBrickStairsFacing, - pub half: NetherBrickStairsHalf, pub shape: NetherBrickStairsShape, + pub half: NetherBrickStairsHalf, + pub facing: NetherBrickStairsFacing, pub waterlogged: bool, } impl NetherBrickStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: NetherBrickStairsFacing::from_snake_case(map.get("facing")?)?, - half: NetherBrickStairsHalf::from_snake_case(map.get("half")?)?, shape: NetherBrickStairsShape::from_snake_case(map.get("shape")?)?, + half: NetherBrickStairsHalf::from_snake_case(map.get("half")?)?, + facing: NetherBrickStairsFacing::from_snake_case(map.get("facing")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for NetherBrickStairsData { + fn default() -> Self { + Self { + shape: NetherBrickStairsShape::Straight, + half: NetherBrickStairsHalf::Bottom, + facing: NetherBrickStairsFacing::North, + waterlogged: false, + } + } +} impl Value for NetherBrickStairsData { fn value(&self) -> usize { - (self.facing.value() * 20usize) - + (self.half.value() * 10usize) - + (self.shape.value() * 2usize) + (self.shape.value() * 16usize) + + (self.half.value() * 8usize) + + (self.facing.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] @@ -10515,18 +13139,18 @@ impl Value for NetherBrickStairsData { if val >= 80usize { return None; } - let facing = NetherBrickStairsFacing::from_value(val / 20usize).unwrap(); - val -= (facing.value() - 0usize) * 20usize; - let half = NetherBrickStairsHalf::from_value(val / 10usize).unwrap(); - val -= (half.value() - 0usize) * 10usize; - let shape = NetherBrickStairsShape::from_value(val / 2usize).unwrap(); - val -= (shape.value() - 0usize) * 2usize; + let shape = NetherBrickStairsShape::from_value(val / 16usize).unwrap(); + val -= (shape.value() - 0usize) * 16usize; + let half = NetherBrickStairsHalf::from_value(val / 8usize).unwrap(); + val -= (half.value() - 0usize) * 8usize; + let facing = NetherBrickStairsFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; let waterlogged = bool::from_value(val / 1usize).unwrap(); val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { - facing, - half, shape, + half, + facing, waterlogged, }) } @@ -10547,6 +13171,11 @@ impl NetherWartData { m } } +impl Default for NetherWartData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for NetherWartData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -10563,28 +13192,28 @@ impl Value for NetherWartData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BrewingStandData { - pub has_bottle_1: bool, pub has_bottle_0: bool, + pub has_bottle_1: bool, pub has_bottle_2: bool, } impl BrewingStandData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - has_bottle_1: bool::from_snake_case(map.get("has_bottle_1")?)?, has_bottle_0: bool::from_snake_case(map.get("has_bottle_0")?)?, + has_bottle_1: bool::from_snake_case(map.get("has_bottle_1")?)?, has_bottle_2: bool::from_snake_case(map.get("has_bottle_2")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert( - "has_bottle_1".to_string(), - self.has_bottle_1.to_snake_case(), - ); m.insert( "has_bottle_0".to_string(), self.has_bottle_0.to_snake_case(), ); + m.insert( + "has_bottle_1".to_string(), + self.has_bottle_1.to_snake_case(), + ); m.insert( "has_bottle_2".to_string(), self.has_bottle_2.to_snake_case(), @@ -10592,10 +13221,19 @@ impl BrewingStandData { m } } +impl Default for BrewingStandData { + fn default() -> Self { + Self { + has_bottle_0: false, + has_bottle_1: false, + has_bottle_2: false, + } + } +} impl Value for BrewingStandData { fn value(&self) -> usize { - (self.has_bottle_1.value() * 4usize) - + (self.has_bottle_0.value() * 2usize) + (self.has_bottle_0.value() * 4usize) + + (self.has_bottle_1.value() * 2usize) + (self.has_bottle_2.value() * 1usize) } #[allow(warnings)] @@ -10603,15 +13241,15 @@ impl Value for BrewingStandData { if val >= 8usize { return None; } - let has_bottle_1 = bool::from_value(val / 4usize).unwrap(); - val -= (has_bottle_1.value() - 0usize) * 4usize; - let has_bottle_0 = bool::from_value(val / 2usize).unwrap(); - val -= (has_bottle_0.value() - 0usize) * 2usize; + let has_bottle_0 = bool::from_value(val / 4usize).unwrap(); + val -= (has_bottle_0.value() - 0usize) * 4usize; + let has_bottle_1 = bool::from_value(val / 2usize).unwrap(); + val -= (has_bottle_1.value() - 0usize) * 2usize; let has_bottle_2 = bool::from_value(val / 1usize).unwrap(); val -= (has_bottle_2.value() - 0usize) * 1usize; Some(Self { - has_bottle_1, has_bottle_0, + has_bottle_1, has_bottle_2, }) } @@ -10632,6 +13270,11 @@ impl CauldronData { m } } +impl Default for CauldronData { + fn default() -> Self { + Self { level: 0 } + } +} impl Value for CauldronData { fn value(&self) -> usize { (self.level.value() * 1usize) @@ -10648,37 +13291,45 @@ impl Value for CauldronData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct EndPortalFrameData { - pub eye: bool, pub facing: EndPortalFrameFacing, + pub eye: bool, } impl EndPortalFrameData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - eye: bool::from_snake_case(map.get("eye")?)?, facing: EndPortalFrameFacing::from_snake_case(map.get("facing")?)?, + eye: bool::from_snake_case(map.get("eye")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("eye".to_string(), self.eye.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("eye".to_string(), self.eye.to_snake_case()); m } } +impl Default for EndPortalFrameData { + fn default() -> Self { + Self { + facing: EndPortalFrameFacing::North, + eye: false, + } + } +} impl Value for EndPortalFrameData { fn value(&self) -> usize { - (self.eye.value() * 4usize) + (self.facing.value() * 1usize) + (self.facing.value() * 2usize) + (self.eye.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 8usize { return None; } - let eye = bool::from_value(val / 4usize).unwrap(); - val -= (eye.value() - 0usize) * 4usize; - let facing = EndPortalFrameFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; - Some(Self { eye, facing }) + let facing = EndPortalFrameFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let eye = bool::from_value(val / 1usize).unwrap(); + val -= (eye.value() - 0usize) * 1usize; + Some(Self { facing, eye }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] @@ -10697,6 +13348,11 @@ impl RedstoneLampData { m } } +impl Default for RedstoneLampData { + fn default() -> Self { + Self { lit: false } + } +} impl Value for RedstoneLampData { fn value(&self) -> usize { (self.lit.value() * 1usize) @@ -10730,6 +13386,14 @@ impl CocoaData { m } } +impl Default for CocoaData { + fn default() -> Self { + Self { + age: 0, + facing: CocoaFacing::North, + } + } +} impl Value for CocoaData { fn value(&self) -> usize { (self.age.value() * 4usize) + (self.facing.value() * 1usize) @@ -10748,245 +13412,295 @@ impl Value for CocoaData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct SandstoneStairsData { + pub waterlogged: bool, + pub half: SandstoneStairsHalf, pub facing: SandstoneStairsFacing, pub shape: SandstoneStairsShape, - pub half: SandstoneStairsHalf, - pub waterlogged: bool, } impl SandstoneStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + half: SandstoneStairsHalf::from_snake_case(map.get("half")?)?, facing: SandstoneStairsFacing::from_snake_case(map.get("facing")?)?, shape: SandstoneStairsShape::from_snake_case(map.get("shape")?)?, - half: SandstoneStairsHalf::from_snake_case(map.get("half")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for SandstoneStairsData { + fn default() -> Self { + Self { + waterlogged: false, + half: SandstoneStairsHalf::Bottom, + facing: SandstoneStairsFacing::North, + shape: SandstoneStairsShape::Straight, + } + } +} impl Value for SandstoneStairsData { fn value(&self) -> usize { - (self.facing.value() * 20usize) - + (self.shape.value() * 4usize) - + (self.half.value() * 2usize) - + (self.waterlogged.value() * 1usize) + (self.waterlogged.value() * 40usize) + + (self.half.value() * 20usize) + + (self.facing.value() * 5usize) + + (self.shape.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 80usize { return None; } - let facing = SandstoneStairsFacing::from_value(val / 20usize).unwrap(); - val -= (facing.value() - 0usize) * 20usize; - let shape = SandstoneStairsShape::from_value(val / 4usize).unwrap(); - val -= (shape.value() - 0usize) * 4usize; - let half = SandstoneStairsHalf::from_value(val / 2usize).unwrap(); - val -= (half.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let waterlogged = bool::from_value(val / 40usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 40usize; + let half = SandstoneStairsHalf::from_value(val / 20usize).unwrap(); + val -= (half.value() - 0usize) * 20usize; + let facing = SandstoneStairsFacing::from_value(val / 5usize).unwrap(); + val -= (facing.value() - 0usize) * 5usize; + let shape = SandstoneStairsShape::from_value(val / 1usize).unwrap(); + val -= (shape.value() - 0usize) * 1usize; Some(Self { + waterlogged, + half, facing, shape, - half, - waterlogged, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct EnderChestData { - pub facing: EnderChestFacing, pub waterlogged: bool, + pub facing: EnderChestFacing, } impl EnderChestData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: EnderChestFacing::from_snake_case(map.get("facing")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + facing: EnderChestFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for EnderChestData { + fn default() -> Self { + Self { + waterlogged: false, + facing: EnderChestFacing::North, + } + } +} impl Value for EnderChestData { fn value(&self) -> usize { - (self.facing.value() * 2usize) + (self.waterlogged.value() * 1usize) + (self.waterlogged.value() * 4usize) + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 8usize { return None; } - let facing = EnderChestFacing::from_value(val / 2usize).unwrap(); - val -= (facing.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let waterlogged = bool::from_value(val / 4usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 4usize; + let facing = EnderChestFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { - facing, waterlogged, + facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct TripwireHookData { - pub powered: bool, - pub attached: bool, pub facing: TripwireHookFacing, + pub attached: bool, + pub powered: bool, } impl TripwireHookData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - powered: bool::from_snake_case(map.get("powered")?)?, - attached: bool::from_snake_case(map.get("attached")?)?, facing: TripwireHookFacing::from_snake_case(map.get("facing")?)?, + attached: bool::from_snake_case(map.get("attached")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("powered".to_string(), self.powered.to_snake_case()); - m.insert("attached".to_string(), self.attached.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("attached".to_string(), self.attached.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for TripwireHookData { + fn default() -> Self { + Self { + facing: TripwireHookFacing::North, + attached: false, + powered: false, + } + } +} impl Value for TripwireHookData { fn value(&self) -> usize { - (self.powered.value() * 8usize) - + (self.attached.value() * 4usize) - + (self.facing.value() * 1usize) + (self.facing.value() * 4usize) + + (self.attached.value() * 2usize) + + (self.powered.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 16usize { return None; } - let powered = bool::from_value(val / 8usize).unwrap(); - val -= (powered.value() - 0usize) * 8usize; - let attached = bool::from_value(val / 4usize).unwrap(); - val -= (attached.value() - 0usize) * 4usize; - let facing = TripwireHookFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let facing = TripwireHookFacing::from_value(val / 4usize).unwrap(); + val -= (facing.value() - 0usize) * 4usize; + let attached = bool::from_value(val / 2usize).unwrap(); + val -= (attached.value() - 0usize) * 2usize; + let powered = bool::from_value(val / 1usize).unwrap(); + val -= (powered.value() - 0usize) * 1usize; Some(Self { - powered, - attached, facing, + attached, + powered, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct TripwireData { - pub east: bool, pub south: bool, pub west: bool, - pub north: bool, - pub disarmed: bool, + pub east: bool, pub attached: bool, + pub north: bool, pub powered: bool, + pub disarmed: bool, } impl TripwireData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - east: bool::from_snake_case(map.get("east")?)?, south: bool::from_snake_case(map.get("south")?)?, west: bool::from_snake_case(map.get("west")?)?, - north: bool::from_snake_case(map.get("north")?)?, - disarmed: bool::from_snake_case(map.get("disarmed")?)?, + east: bool::from_snake_case(map.get("east")?)?, attached: bool::from_snake_case(map.get("attached")?)?, + north: bool::from_snake_case(map.get("north")?)?, powered: bool::from_snake_case(map.get("powered")?)?, + disarmed: bool::from_snake_case(map.get("disarmed")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("east".to_string(), self.east.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("disarmed".to_string(), self.disarmed.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m.insert("attached".to_string(), self.attached.to_snake_case()); + m.insert("north".to_string(), self.north.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); + m.insert("disarmed".to_string(), self.disarmed.to_snake_case()); m } } +impl Default for TripwireData { + fn default() -> Self { + Self { + south: false, + west: false, + east: false, + attached: false, + north: false, + powered: false, + disarmed: false, + } + } +} impl Value for TripwireData { fn value(&self) -> usize { - (self.east.value() * 64usize) - + (self.south.value() * 32usize) - + (self.west.value() * 16usize) - + (self.north.value() * 8usize) - + (self.disarmed.value() * 4usize) - + (self.attached.value() * 2usize) - + (self.powered.value() * 1usize) + (self.south.value() * 64usize) + + (self.west.value() * 32usize) + + (self.east.value() * 16usize) + + (self.attached.value() * 8usize) + + (self.north.value() * 4usize) + + (self.powered.value() * 2usize) + + (self.disarmed.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 128usize { return None; } - let east = bool::from_value(val / 64usize).unwrap(); - val -= (east.value() - 0usize) * 64usize; - let south = bool::from_value(val / 32usize).unwrap(); - val -= (south.value() - 0usize) * 32usize; - let west = bool::from_value(val / 16usize).unwrap(); - val -= (west.value() - 0usize) * 16usize; - let north = bool::from_value(val / 8usize).unwrap(); - val -= (north.value() - 0usize) * 8usize; - let disarmed = bool::from_value(val / 4usize).unwrap(); - val -= (disarmed.value() - 0usize) * 4usize; - let attached = bool::from_value(val / 2usize).unwrap(); - val -= (attached.value() - 0usize) * 2usize; - let powered = bool::from_value(val / 1usize).unwrap(); - val -= (powered.value() - 0usize) * 1usize; + let south = bool::from_value(val / 64usize).unwrap(); + val -= (south.value() - 0usize) * 64usize; + let west = bool::from_value(val / 32usize).unwrap(); + val -= (west.value() - 0usize) * 32usize; + let east = bool::from_value(val / 16usize).unwrap(); + val -= (east.value() - 0usize) * 16usize; + let attached = bool::from_value(val / 8usize).unwrap(); + val -= (attached.value() - 0usize) * 8usize; + let north = bool::from_value(val / 4usize).unwrap(); + val -= (north.value() - 0usize) * 4usize; + let powered = bool::from_value(val / 2usize).unwrap(); + val -= (powered.value() - 0usize) * 2usize; + let disarmed = bool::from_value(val / 1usize).unwrap(); + val -= (disarmed.value() - 0usize) * 1usize; Some(Self { - east, south, west, - north, - disarmed, + east, attached, + north, powered, + disarmed, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct SpruceStairsData { pub facing: SpruceStairsFacing, - pub shape: SpruceStairsShape, pub half: SpruceStairsHalf, + pub shape: SpruceStairsShape, pub waterlogged: bool, } impl SpruceStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { facing: SpruceStairsFacing::from_snake_case(map.get("facing")?)?, - shape: SpruceStairsShape::from_snake_case(map.get("shape")?)?, half: SpruceStairsHalf::from_snake_case(map.get("half")?)?, + shape: SpruceStairsShape::from_snake_case(map.get("shape")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("shape".to_string(), self.shape.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("shape".to_string(), self.shape.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for SpruceStairsData { + fn default() -> Self { + Self { + facing: SpruceStairsFacing::North, + half: SpruceStairsHalf::Bottom, + shape: SpruceStairsShape::Straight, + waterlogged: false, + } + } +} impl Value for SpruceStairsData { fn value(&self) -> usize { (self.facing.value() * 20usize) - + (self.shape.value() * 4usize) - + (self.half.value() * 2usize) + + (self.half.value() * 10usize) + + (self.shape.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] @@ -10996,102 +13710,122 @@ impl Value for SpruceStairsData { } let facing = SpruceStairsFacing::from_value(val / 20usize).unwrap(); val -= (facing.value() - 0usize) * 20usize; - let shape = SpruceStairsShape::from_value(val / 4usize).unwrap(); - val -= (shape.value() - 0usize) * 4usize; - let half = SpruceStairsHalf::from_value(val / 2usize).unwrap(); - val -= (half.value() - 0usize) * 2usize; + let half = SpruceStairsHalf::from_value(val / 10usize).unwrap(); + val -= (half.value() - 0usize) * 10usize; + let shape = SpruceStairsShape::from_value(val / 2usize).unwrap(); + val -= (shape.value() - 0usize) * 2usize; let waterlogged = bool::from_value(val / 1usize).unwrap(); val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { facing, - shape, half, + shape, waterlogged, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BirchStairsData { - pub facing: BirchStairsFacing, pub shape: BirchStairsShape, - pub half: BirchStairsHalf, pub waterlogged: bool, + pub half: BirchStairsHalf, + pub facing: BirchStairsFacing, } impl BirchStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: BirchStairsFacing::from_snake_case(map.get("facing")?)?, shape: BirchStairsShape::from_snake_case(map.get("shape")?)?, - half: BirchStairsHalf::from_snake_case(map.get("half")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + half: BirchStairsHalf::from_snake_case(map.get("half")?)?, + facing: BirchStairsFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for BirchStairsData { + fn default() -> Self { + Self { + shape: BirchStairsShape::Straight, + waterlogged: false, + half: BirchStairsHalf::Bottom, + facing: BirchStairsFacing::North, + } + } +} impl Value for BirchStairsData { fn value(&self) -> usize { - (self.facing.value() * 20usize) - + (self.shape.value() * 4usize) - + (self.half.value() * 2usize) - + (self.waterlogged.value() * 1usize) + (self.shape.value() * 16usize) + + (self.waterlogged.value() * 8usize) + + (self.half.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 80usize { return None; } - let facing = BirchStairsFacing::from_value(val / 20usize).unwrap(); - val -= (facing.value() - 0usize) * 20usize; - let shape = BirchStairsShape::from_value(val / 4usize).unwrap(); - val -= (shape.value() - 0usize) * 4usize; - let half = BirchStairsHalf::from_value(val / 2usize).unwrap(); - val -= (half.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let shape = BirchStairsShape::from_value(val / 16usize).unwrap(); + val -= (shape.value() - 0usize) * 16usize; + let waterlogged = bool::from_value(val / 8usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 8usize; + let half = BirchStairsHalf::from_value(val / 4usize).unwrap(); + val -= (half.value() - 0usize) * 4usize; + let facing = BirchStairsFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { - facing, shape, - half, waterlogged, + half, + facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct JungleStairsData { - pub waterlogged: bool, pub facing: JungleStairsFacing, + pub waterlogged: bool, pub shape: JungleStairsShape, pub half: JungleStairsHalf, } impl JungleStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, facing: JungleStairsFacing::from_snake_case(map.get("facing")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, shape: JungleStairsShape::from_snake_case(map.get("shape")?)?, half: JungleStairsHalf::from_snake_case(map.get("half")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); m } } +impl Default for JungleStairsData { + fn default() -> Self { + Self { + facing: JungleStairsFacing::North, + waterlogged: false, + shape: JungleStairsShape::Straight, + half: JungleStairsHalf::Bottom, + } + } +} impl Value for JungleStairsData { fn value(&self) -> usize { - (self.waterlogged.value() * 40usize) - + (self.facing.value() * 10usize) + (self.facing.value() * 20usize) + + (self.waterlogged.value() * 10usize) + (self.shape.value() * 2usize) + (self.half.value() * 1usize) } @@ -11100,17 +13834,17 @@ impl Value for JungleStairsData { if val >= 80usize { return None; } - let waterlogged = bool::from_value(val / 40usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 40usize; - let facing = JungleStairsFacing::from_value(val / 10usize).unwrap(); - val -= (facing.value() - 0usize) * 10usize; + let facing = JungleStairsFacing::from_value(val / 20usize).unwrap(); + val -= (facing.value() - 0usize) * 20usize; + let waterlogged = bool::from_value(val / 10usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 10usize; let shape = JungleStairsShape::from_value(val / 2usize).unwrap(); val -= (shape.value() - 0usize) * 2usize; let half = JungleStairsHalf::from_value(val / 1usize).unwrap(); val -= (half.value() - 0usize) * 1usize; Some(Self { - waterlogged, facing, + waterlogged, shape, half, }) @@ -11135,6 +13869,14 @@ impl CommandBlockData { m } } +impl Default for CommandBlockData { + fn default() -> Self { + Self { + conditional: false, + facing: CommandBlockFacing::North, + } + } +} impl Value for CommandBlockData { fn value(&self) -> usize { (self.conditional.value() * 6usize) + (self.facing.value() * 1usize) @@ -11156,42 +13898,54 @@ impl Value for CommandBlockData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct CobblestoneWallData { - pub west: bool, - pub north: bool, - pub south: bool, pub east: bool, pub up: bool, + pub south: bool, + pub north: bool, + pub west: bool, pub waterlogged: bool, } impl CobblestoneWallData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - west: bool::from_snake_case(map.get("west")?)?, - north: bool::from_snake_case(map.get("north")?)?, - south: bool::from_snake_case(map.get("south")?)?, east: bool::from_snake_case(map.get("east")?)?, up: bool::from_snake_case(map.get("up")?)?, + south: bool::from_snake_case(map.get("south")?)?, + north: bool::from_snake_case(map.get("north")?)?, + west: bool::from_snake_case(map.get("west")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); m.insert("up".to_string(), self.up.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); + m.insert("north".to_string(), self.north.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for CobblestoneWallData { + fn default() -> Self { + Self { + east: false, + up: true, + south: false, + north: false, + west: false, + waterlogged: false, + } + } +} impl Value for CobblestoneWallData { fn value(&self) -> usize { - (self.west.value() * 32usize) - + (self.north.value() * 16usize) + (self.east.value() * 32usize) + + (self.up.value() * 16usize) + (self.south.value() * 8usize) - + (self.east.value() * 4usize) - + (self.up.value() * 2usize) + + (self.north.value() * 4usize) + + (self.west.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] @@ -11199,92 +13953,104 @@ impl Value for CobblestoneWallData { if val >= 64usize { return None; } - let west = bool::from_value(val / 32usize).unwrap(); - val -= (west.value() - 0usize) * 32usize; - let north = bool::from_value(val / 16usize).unwrap(); - val -= (north.value() - 0usize) * 16usize; + let east = bool::from_value(val / 32usize).unwrap(); + val -= (east.value() - 0usize) * 32usize; + let up = bool::from_value(val / 16usize).unwrap(); + val -= (up.value() - 0usize) * 16usize; let south = bool::from_value(val / 8usize).unwrap(); val -= (south.value() - 0usize) * 8usize; - let east = bool::from_value(val / 4usize).unwrap(); - val -= (east.value() - 0usize) * 4usize; - let up = bool::from_value(val / 2usize).unwrap(); - val -= (up.value() - 0usize) * 2usize; + let north = bool::from_value(val / 4usize).unwrap(); + val -= (north.value() - 0usize) * 4usize; + let west = bool::from_value(val / 2usize).unwrap(); + val -= (west.value() - 0usize) * 2usize; let waterlogged = bool::from_value(val / 1usize).unwrap(); val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { - west, - north, - south, east, up, + south, + north, + west, waterlogged, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct MossyCobblestoneWallData { - pub east: bool, - pub west: bool, + pub south: bool, pub north: bool, pub waterlogged: bool, + pub east: bool, pub up: bool, - pub south: bool, + pub west: bool, } impl MossyCobblestoneWallData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - east: bool::from_snake_case(map.get("east")?)?, - west: bool::from_snake_case(map.get("west")?)?, + south: bool::from_snake_case(map.get("south")?)?, north: bool::from_snake_case(map.get("north")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + east: bool::from_snake_case(map.get("east")?)?, up: bool::from_snake_case(map.get("up")?)?, - south: bool::from_snake_case(map.get("south")?)?, + west: bool::from_snake_case(map.get("west")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m.insert("up".to_string(), self.up.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); m } } +impl Default for MossyCobblestoneWallData { + fn default() -> Self { + Self { + south: false, + north: false, + waterlogged: false, + east: false, + up: true, + west: false, + } + } +} impl Value for MossyCobblestoneWallData { fn value(&self) -> usize { - (self.east.value() * 32usize) - + (self.west.value() * 16usize) - + (self.north.value() * 8usize) - + (self.waterlogged.value() * 4usize) + (self.south.value() * 32usize) + + (self.north.value() * 16usize) + + (self.waterlogged.value() * 8usize) + + (self.east.value() * 4usize) + (self.up.value() * 2usize) - + (self.south.value() * 1usize) + + (self.west.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 64usize { return None; } - let east = bool::from_value(val / 32usize).unwrap(); - val -= (east.value() - 0usize) * 32usize; - let west = bool::from_value(val / 16usize).unwrap(); - val -= (west.value() - 0usize) * 16usize; - let north = bool::from_value(val / 8usize).unwrap(); - val -= (north.value() - 0usize) * 8usize; - let waterlogged = bool::from_value(val / 4usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 4usize; + let south = bool::from_value(val / 32usize).unwrap(); + val -= (south.value() - 0usize) * 32usize; + let north = bool::from_value(val / 16usize).unwrap(); + val -= (north.value() - 0usize) * 16usize; + let waterlogged = bool::from_value(val / 8usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 8usize; + let east = bool::from_value(val / 4usize).unwrap(); + val -= (east.value() - 0usize) * 4usize; let up = bool::from_value(val / 2usize).unwrap(); val -= (up.value() - 0usize) * 2usize; - let south = bool::from_value(val / 1usize).unwrap(); - val -= (south.value() - 0usize) * 1usize; + let west = bool::from_value(val / 1usize).unwrap(); + val -= (west.value() - 0usize) * 1usize; Some(Self { - east, - west, + south, north, waterlogged, + east, up, - south, + west, }) } } @@ -11304,6 +14070,11 @@ impl CarrotsData { m } } +impl Default for CarrotsData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for CarrotsData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -11334,6 +14105,11 @@ impl PotatoesData { m } } +impl Default for PotatoesData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for PotatoesData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -11350,168 +14126,204 @@ impl Value for PotatoesData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct OakButtonData { + pub facing: OakButtonFacing, pub powered: bool, pub face: OakButtonFace, - pub facing: OakButtonFacing, } impl OakButtonData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + facing: OakButtonFacing::from_snake_case(map.get("facing")?)?, powered: bool::from_snake_case(map.get("powered")?)?, face: OakButtonFace::from_snake_case(map.get("face")?)?, - facing: OakButtonFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("face".to_string(), self.face.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for OakButtonData { + fn default() -> Self { + Self { + facing: OakButtonFacing::North, + powered: false, + face: OakButtonFace::Wall, + } + } +} impl Value for OakButtonData { fn value(&self) -> usize { - (self.powered.value() * 12usize) - + (self.face.value() * 4usize) - + (self.facing.value() * 1usize) + (self.facing.value() * 6usize) + + (self.powered.value() * 3usize) + + (self.face.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 24usize { return None; } - let powered = bool::from_value(val / 12usize).unwrap(); - val -= (powered.value() - 0usize) * 12usize; - let face = OakButtonFace::from_value(val / 4usize).unwrap(); - val -= (face.value() - 0usize) * 4usize; - let facing = OakButtonFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let facing = OakButtonFacing::from_value(val / 6usize).unwrap(); + val -= (facing.value() - 0usize) * 6usize; + let powered = bool::from_value(val / 3usize).unwrap(); + val -= (powered.value() - 0usize) * 3usize; + let face = OakButtonFace::from_value(val / 1usize).unwrap(); + val -= (face.value() - 0usize) * 1usize; Some(Self { + facing, powered, face, - facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct SpruceButtonData { + pub powered: bool, pub facing: SpruceButtonFacing, pub face: SpruceButtonFace, - pub powered: bool, } impl SpruceButtonData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + powered: bool::from_snake_case(map.get("powered")?)?, facing: SpruceButtonFacing::from_snake_case(map.get("facing")?)?, face: SpruceButtonFace::from_snake_case(map.get("face")?)?, - powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("face".to_string(), self.face.to_snake_case()); - m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for SpruceButtonData { + fn default() -> Self { + Self { + powered: false, + facing: SpruceButtonFacing::North, + face: SpruceButtonFace::Wall, + } + } +} impl Value for SpruceButtonData { fn value(&self) -> usize { - (self.facing.value() * 6usize) - + (self.face.value() * 2usize) - + (self.powered.value() * 1usize) + (self.powered.value() * 12usize) + + (self.facing.value() * 3usize) + + (self.face.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 24usize { return None; } - let facing = SpruceButtonFacing::from_value(val / 6usize).unwrap(); - val -= (facing.value() - 0usize) * 6usize; - let face = SpruceButtonFace::from_value(val / 2usize).unwrap(); - val -= (face.value() - 0usize) * 2usize; - let powered = bool::from_value(val / 1usize).unwrap(); - val -= (powered.value() - 0usize) * 1usize; + let powered = bool::from_value(val / 12usize).unwrap(); + val -= (powered.value() - 0usize) * 12usize; + let facing = SpruceButtonFacing::from_value(val / 3usize).unwrap(); + val -= (facing.value() - 0usize) * 3usize; + let face = SpruceButtonFace::from_value(val / 1usize).unwrap(); + val -= (face.value() - 0usize) * 1usize; Some(Self { + powered, facing, face, - powered, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BirchButtonData { + pub powered: bool, pub face: BirchButtonFace, pub facing: BirchButtonFacing, - pub powered: bool, } impl BirchButtonData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + powered: bool::from_snake_case(map.get("powered")?)?, face: BirchButtonFace::from_snake_case(map.get("face")?)?, facing: BirchButtonFacing::from_snake_case(map.get("facing")?)?, - powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("face".to_string(), self.face.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for BirchButtonData { + fn default() -> Self { + Self { + powered: false, + face: BirchButtonFace::Wall, + facing: BirchButtonFacing::North, + } + } +} impl Value for BirchButtonData { fn value(&self) -> usize { - (self.face.value() * 8usize) - + (self.facing.value() * 2usize) - + (self.powered.value() * 1usize) + (self.powered.value() * 12usize) + + (self.face.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 24usize { return None; } - let face = BirchButtonFace::from_value(val / 8usize).unwrap(); - val -= (face.value() - 0usize) * 8usize; - let facing = BirchButtonFacing::from_value(val / 2usize).unwrap(); - val -= (facing.value() - 0usize) * 2usize; - let powered = bool::from_value(val / 1usize).unwrap(); - val -= (powered.value() - 0usize) * 1usize; + let powered = bool::from_value(val / 12usize).unwrap(); + val -= (powered.value() - 0usize) * 12usize; + let face = BirchButtonFace::from_value(val / 4usize).unwrap(); + val -= (face.value() - 0usize) * 4usize; + let facing = BirchButtonFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { + powered, face, facing, - powered, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct JungleButtonData { - pub facing: JungleButtonFacing, pub face: JungleButtonFace, + pub facing: JungleButtonFacing, pub powered: bool, } impl JungleButtonData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: JungleButtonFacing::from_snake_case(map.get("facing")?)?, face: JungleButtonFace::from_snake_case(map.get("face")?)?, + facing: JungleButtonFacing::from_snake_case(map.get("facing")?)?, powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("face".to_string(), self.face.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for JungleButtonData { + fn default() -> Self { + Self { + face: JungleButtonFace::Wall, + facing: JungleButtonFacing::North, + powered: false, + } + } +} impl Value for JungleButtonData { fn value(&self) -> usize { - (self.facing.value() * 6usize) - + (self.face.value() * 2usize) + (self.face.value() * 8usize) + + (self.facing.value() * 2usize) + (self.powered.value() * 1usize) } #[allow(warnings)] @@ -11519,45 +14331,54 @@ impl Value for JungleButtonData { if val >= 24usize { return None; } - let facing = JungleButtonFacing::from_value(val / 6usize).unwrap(); - val -= (facing.value() - 0usize) * 6usize; - let face = JungleButtonFace::from_value(val / 2usize).unwrap(); - val -= (face.value() - 0usize) * 2usize; + let face = JungleButtonFace::from_value(val / 8usize).unwrap(); + val -= (face.value() - 0usize) * 8usize; + let facing = JungleButtonFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; let powered = bool::from_value(val / 1usize).unwrap(); val -= (powered.value() - 0usize) * 1usize; Some(Self { - facing, face, + facing, powered, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct AcaciaButtonData { - pub powered: bool, pub facing: AcaciaButtonFacing, + pub powered: bool, pub face: AcaciaButtonFace, } impl AcaciaButtonData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - powered: bool::from_snake_case(map.get("powered")?)?, facing: AcaciaButtonFacing::from_snake_case(map.get("facing")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, face: AcaciaButtonFace::from_snake_case(map.get("face")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("face".to_string(), self.face.to_snake_case()); m } } +impl Default for AcaciaButtonData { + fn default() -> Self { + Self { + facing: AcaciaButtonFacing::North, + powered: false, + face: AcaciaButtonFace::Wall, + } + } +} impl Value for AcaciaButtonData { fn value(&self) -> usize { - (self.powered.value() * 12usize) - + (self.facing.value() * 3usize) + (self.facing.value() * 6usize) + + (self.powered.value() * 3usize) + (self.face.value() * 1usize) } #[allow(warnings)] @@ -11565,15 +14386,15 @@ impl Value for AcaciaButtonData { if val >= 24usize { return None; } - let powered = bool::from_value(val / 12usize).unwrap(); - val -= (powered.value() - 0usize) * 12usize; - let facing = AcaciaButtonFacing::from_value(val / 3usize).unwrap(); - val -= (facing.value() - 0usize) * 3usize; + let facing = AcaciaButtonFacing::from_value(val / 6usize).unwrap(); + val -= (facing.value() - 0usize) * 6usize; + let powered = bool::from_value(val / 3usize).unwrap(); + val -= (powered.value() - 0usize) * 3usize; let face = AcaciaButtonFace::from_value(val / 1usize).unwrap(); val -= (face.value() - 0usize) * 1usize; Some(Self { - powered, facing, + powered, face, }) } @@ -11581,30 +14402,39 @@ impl Value for AcaciaButtonData { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DarkOakButtonData { pub face: DarkOakButtonFace, - pub facing: DarkOakButtonFacing, pub powered: bool, + pub facing: DarkOakButtonFacing, } impl DarkOakButtonData { pub fn from_map(map: &HashMap) -> Option { Some(Self { face: DarkOakButtonFace::from_snake_case(map.get("face")?)?, - facing: DarkOakButtonFacing::from_snake_case(map.get("facing")?)?, powered: bool::from_snake_case(map.get("powered")?)?, + facing: DarkOakButtonFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("face".to_string(), self.face.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for DarkOakButtonData { + fn default() -> Self { + Self { + face: DarkOakButtonFace::Wall, + powered: false, + facing: DarkOakButtonFacing::North, + } + } +} impl Value for DarkOakButtonData { fn value(&self) -> usize { (self.face.value() * 8usize) - + (self.facing.value() * 2usize) - + (self.powered.value() * 1usize) + + (self.powered.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -11613,14 +14443,14 @@ impl Value for DarkOakButtonData { } let face = DarkOakButtonFace::from_value(val / 8usize).unwrap(); val -= (face.value() - 0usize) * 8usize; - let facing = DarkOakButtonFacing::from_value(val / 2usize).unwrap(); - val -= (facing.value() - 0usize) * 2usize; - let powered = bool::from_value(val / 1usize).unwrap(); - val -= (powered.value() - 0usize) * 1usize; + let powered = bool::from_value(val / 4usize).unwrap(); + val -= (powered.value() - 0usize) * 4usize; + let facing = DarkOakButtonFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { face, - facing, powered, + facing, }) } } @@ -11640,6 +14470,13 @@ impl SkeletonWallSkullData { m } } +impl Default for SkeletonWallSkullData { + fn default() -> Self { + Self { + facing: SkeletonWallSkullFacing::North, + } + } +} impl Value for SkeletonWallSkullData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -11670,6 +14507,11 @@ impl SkeletonSkullData { m } } +impl Default for SkeletonSkullData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for SkeletonSkullData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -11700,6 +14542,13 @@ impl WitherSkeletonWallSkullData { m } } +impl Default for WitherSkeletonWallSkullData { + fn default() -> Self { + Self { + facing: WitherSkeletonWallSkullFacing::North, + } + } +} impl Value for WitherSkeletonWallSkullData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -11730,6 +14579,11 @@ impl WitherSkeletonSkullData { m } } +impl Default for WitherSkeletonSkullData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for WitherSkeletonSkullData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -11760,6 +14614,13 @@ impl ZombieWallHeadData { m } } +impl Default for ZombieWallHeadData { + fn default() -> Self { + Self { + facing: ZombieWallHeadFacing::North, + } + } +} impl Value for ZombieWallHeadData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -11790,6 +14651,11 @@ impl ZombieHeadData { m } } +impl Default for ZombieHeadData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for ZombieHeadData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -11820,6 +14686,13 @@ impl PlayerWallHeadData { m } } +impl Default for PlayerWallHeadData { + fn default() -> Self { + Self { + facing: PlayerWallHeadFacing::North, + } + } +} impl Value for PlayerWallHeadData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -11850,6 +14723,11 @@ impl PlayerHeadData { m } } +impl Default for PlayerHeadData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for PlayerHeadData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -11880,6 +14758,13 @@ impl CreeperWallHeadData { m } } +impl Default for CreeperWallHeadData { + fn default() -> Self { + Self { + facing: CreeperWallHeadFacing::North, + } + } +} impl Value for CreeperWallHeadData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -11910,6 +14795,11 @@ impl CreeperHeadData { m } } +impl Default for CreeperHeadData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for CreeperHeadData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -11940,6 +14830,13 @@ impl DragonWallHeadData { m } } +impl Default for DragonWallHeadData { + fn default() -> Self { + Self { + facing: DragonWallHeadFacing::North, + } + } +} impl Value for DragonWallHeadData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -11970,6 +14867,11 @@ impl DragonHeadData { m } } +impl Default for DragonHeadData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for DragonHeadData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -12000,6 +14902,13 @@ impl AnvilData { m } } +impl Default for AnvilData { + fn default() -> Self { + Self { + facing: AnvilFacing::North, + } + } +} impl Value for AnvilData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -12030,6 +14939,13 @@ impl ChippedAnvilData { m } } +impl Default for ChippedAnvilData { + fn default() -> Self { + Self { + facing: ChippedAnvilFacing::North, + } + } +} impl Value for ChippedAnvilData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -12060,6 +14976,13 @@ impl DamagedAnvilData { m } } +impl Default for DamagedAnvilData { + fn default() -> Self { + Self { + facing: DamagedAnvilFacing::North, + } + } +} impl Value for DamagedAnvilData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -12076,47 +14999,56 @@ impl Value for DamagedAnvilData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct TrappedChestData { - pub waterlogged: bool, pub ty: TrappedChestType, pub facing: TrappedChestFacing, + pub waterlogged: bool, } impl TrappedChestData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, ty: TrappedChestType::from_snake_case(map.get("type")?)?, facing: TrappedChestFacing::from_snake_case(map.get("facing")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("type".to_string(), self.ty.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for TrappedChestData { + fn default() -> Self { + Self { + ty: TrappedChestType::Single, + facing: TrappedChestFacing::North, + waterlogged: false, + } + } +} impl Value for TrappedChestData { fn value(&self) -> usize { - (self.waterlogged.value() * 12usize) - + (self.ty.value() * 4usize) - + (self.facing.value() * 1usize) + (self.ty.value() * 8usize) + + (self.facing.value() * 2usize) + + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 24usize { return None; } - let waterlogged = bool::from_value(val / 12usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 12usize; - let ty = TrappedChestType::from_value(val / 4usize).unwrap(); - val -= (ty.value() - 0usize) * 4usize; - let facing = TrappedChestFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let ty = TrappedChestType::from_value(val / 8usize).unwrap(); + val -= (ty.value() - 0usize) * 8usize; + let facing = TrappedChestFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { - waterlogged, ty, facing, + waterlogged, }) } } @@ -12136,6 +15068,11 @@ impl LightWeightedPressurePlateData { m } } +impl Default for LightWeightedPressurePlateData { + fn default() -> Self { + Self { power: 0 } + } +} impl Value for LightWeightedPressurePlateData { fn value(&self) -> usize { (self.power.value() * 1usize) @@ -12166,6 +15103,11 @@ impl HeavyWeightedPressurePlateData { m } } +impl Default for HeavyWeightedPressurePlateData { + fn default() -> Self { + Self { power: 0 } + } +} impl Value for HeavyWeightedPressurePlateData { fn value(&self) -> usize { (self.power.value() * 1usize) @@ -12182,83 +15124,100 @@ impl Value for HeavyWeightedPressurePlateData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct ComparatorData { - pub facing: ComparatorFacing, - pub powered: bool, pub mode: ComparatorMode, + pub powered: bool, + pub facing: ComparatorFacing, } impl ComparatorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: ComparatorFacing::from_snake_case(map.get("facing")?)?, - powered: bool::from_snake_case(map.get("powered")?)?, mode: ComparatorMode::from_snake_case(map.get("mode")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, + facing: ComparatorFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("mode".to_string(), self.mode.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for ComparatorData { + fn default() -> Self { + Self { + mode: ComparatorMode::Compare, + powered: false, + facing: ComparatorFacing::North, + } + } +} impl Value for ComparatorData { fn value(&self) -> usize { - (self.facing.value() * 4usize) - + (self.powered.value() * 2usize) - + (self.mode.value() * 1usize) + (self.mode.value() * 8usize) + + (self.powered.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 16usize { return None; } - let facing = ComparatorFacing::from_value(val / 4usize).unwrap(); - val -= (facing.value() - 0usize) * 4usize; - let powered = bool::from_value(val / 2usize).unwrap(); - val -= (powered.value() - 0usize) * 2usize; - let mode = ComparatorMode::from_value(val / 1usize).unwrap(); - val -= (mode.value() - 0usize) * 1usize; + let mode = ComparatorMode::from_value(val / 8usize).unwrap(); + val -= (mode.value() - 0usize) * 8usize; + let powered = bool::from_value(val / 4usize).unwrap(); + val -= (powered.value() - 0usize) * 4usize; + let facing = ComparatorFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { - facing, - powered, mode, + powered, + facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DaylightDetectorData { - pub inverted: bool, pub power: i32, + pub inverted: bool, } impl DaylightDetectorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - inverted: bool::from_snake_case(map.get("inverted")?)?, power: i32::from_snake_case(map.get("power")?)?, + inverted: bool::from_snake_case(map.get("inverted")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("inverted".to_string(), self.inverted.to_snake_case()); m.insert("power".to_string(), self.power.to_snake_case()); + m.insert("inverted".to_string(), self.inverted.to_snake_case()); m } } +impl Default for DaylightDetectorData { + fn default() -> Self { + Self { + power: 0, + inverted: false, + } + } +} impl Value for DaylightDetectorData { fn value(&self) -> usize { - (self.inverted.value() * 16usize) + (self.power.value() * 1usize) + (self.power.value() * 2usize) + (self.inverted.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let inverted = bool::from_value(val / 16usize).unwrap(); - val -= (inverted.value() - 0usize) * 16usize; - let power = i32::from_value(val / 1usize).unwrap(); - val -= (power.value() - 0usize) * 1usize; - Some(Self { inverted, power }) + let power = i32::from_value(val / 2usize).unwrap(); + val -= (power.value() - 0usize) * 2usize; + let inverted = bool::from_value(val / 1usize).unwrap(); + val -= (inverted.value() - 0usize) * 1usize; + Some(Self { power, inverted }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] @@ -12280,6 +15239,14 @@ impl HopperData { m } } +impl Default for HopperData { + fn default() -> Self { + Self { + facing: HopperFacing::Down, + enabled: true, + } + } +} impl Value for HopperData { fn value(&self) -> usize { (self.facing.value() * 2usize) + (self.enabled.value() * 1usize) @@ -12312,6 +15279,13 @@ impl QuartzPillarData { m } } +impl Default for QuartzPillarData { + fn default() -> Self { + Self { + axis: QuartzPillarAxis::Y, + } + } +} impl Value for QuartzPillarData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -12328,54 +15302,64 @@ impl Value for QuartzPillarData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct QuartzStairsData { - pub facing: QuartzStairsFacing, pub shape: QuartzStairsShape, pub half: QuartzStairsHalf, pub waterlogged: bool, + pub facing: QuartzStairsFacing, } impl QuartzStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: QuartzStairsFacing::from_snake_case(map.get("facing")?)?, shape: QuartzStairsShape::from_snake_case(map.get("shape")?)?, half: QuartzStairsHalf::from_snake_case(map.get("half")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + facing: QuartzStairsFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for QuartzStairsData { + fn default() -> Self { + Self { + shape: QuartzStairsShape::Straight, + half: QuartzStairsHalf::Bottom, + waterlogged: false, + facing: QuartzStairsFacing::North, + } + } +} impl Value for QuartzStairsData { fn value(&self) -> usize { - (self.facing.value() * 20usize) - + (self.shape.value() * 4usize) - + (self.half.value() * 2usize) - + (self.waterlogged.value() * 1usize) + (self.shape.value() * 16usize) + + (self.half.value() * 8usize) + + (self.waterlogged.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 80usize { return None; } - let facing = QuartzStairsFacing::from_value(val / 20usize).unwrap(); - val -= (facing.value() - 0usize) * 20usize; - let shape = QuartzStairsShape::from_value(val / 4usize).unwrap(); - val -= (shape.value() - 0usize) * 4usize; - let half = QuartzStairsHalf::from_value(val / 2usize).unwrap(); - val -= (half.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let shape = QuartzStairsShape::from_value(val / 16usize).unwrap(); + val -= (shape.value() - 0usize) * 16usize; + let half = QuartzStairsHalf::from_value(val / 8usize).unwrap(); + val -= (half.value() - 0usize) * 8usize; + let waterlogged = bool::from_value(val / 4usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 4usize; + let facing = QuartzStairsFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { - facing, shape, half, waterlogged, + facing, }) } } @@ -12398,6 +15382,14 @@ impl ActivatorRailData { m } } +impl Default for ActivatorRailData { + fn default() -> Self { + Self { + shape: ActivatorRailShape::NorthSouth, + powered: false, + } + } +} impl Value for ActivatorRailData { fn value(&self) -> usize { (self.shape.value() * 2usize) + (self.powered.value() * 1usize) @@ -12416,254 +15408,306 @@ impl Value for ActivatorRailData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DropperData { - pub triggered: bool, pub facing: DropperFacing, + pub triggered: bool, } impl DropperData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - triggered: bool::from_snake_case(map.get("triggered")?)?, facing: DropperFacing::from_snake_case(map.get("facing")?)?, + triggered: bool::from_snake_case(map.get("triggered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("triggered".to_string(), self.triggered.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("triggered".to_string(), self.triggered.to_snake_case()); m } } +impl Default for DropperData { + fn default() -> Self { + Self { + facing: DropperFacing::North, + triggered: false, + } + } +} impl Value for DropperData { fn value(&self) -> usize { - (self.triggered.value() * 6usize) + (self.facing.value() * 1usize) + (self.facing.value() * 2usize) + (self.triggered.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 12usize { return None; } - let triggered = bool::from_value(val / 6usize).unwrap(); - val -= (triggered.value() - 0usize) * 6usize; - let facing = DropperFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; - Some(Self { triggered, facing }) + let facing = DropperFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let triggered = bool::from_value(val / 1usize).unwrap(); + val -= (triggered.value() - 0usize) * 1usize; + Some(Self { facing, triggered }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct WhiteStainedGlassPaneData { - pub waterlogged: bool, pub south: bool, - pub west: bool, pub east: bool, + pub west: bool, pub north: bool, + pub waterlogged: bool, } impl WhiteStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, south: bool::from_snake_case(map.get("south")?)?, - west: bool::from_snake_case(map.get("west")?)?, east: bool::from_snake_case(map.get("east")?)?, + west: bool::from_snake_case(map.get("west")?)?, north: bool::from_snake_case(map.get("north")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for WhiteStainedGlassPaneData { + fn default() -> Self { + Self { + south: false, + east: false, + west: false, + north: false, + waterlogged: false, + } + } +} impl Value for WhiteStainedGlassPaneData { fn value(&self) -> usize { - (self.waterlogged.value() * 16usize) - + (self.south.value() * 8usize) + (self.south.value() * 16usize) + + (self.east.value() * 8usize) + (self.west.value() * 4usize) - + (self.east.value() * 2usize) - + (self.north.value() * 1usize) + + (self.north.value() * 2usize) + + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let waterlogged = bool::from_value(val / 16usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 16usize; - let south = bool::from_value(val / 8usize).unwrap(); - val -= (south.value() - 0usize) * 8usize; + let south = bool::from_value(val / 16usize).unwrap(); + val -= (south.value() - 0usize) * 16usize; + let east = bool::from_value(val / 8usize).unwrap(); + val -= (east.value() - 0usize) * 8usize; let west = bool::from_value(val / 4usize).unwrap(); val -= (west.value() - 0usize) * 4usize; - let east = bool::from_value(val / 2usize).unwrap(); - val -= (east.value() - 0usize) * 2usize; - let north = bool::from_value(val / 1usize).unwrap(); - val -= (north.value() - 0usize) * 1usize; + let north = bool::from_value(val / 2usize).unwrap(); + val -= (north.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { - waterlogged, south, - west, east, + west, north, + waterlogged, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct OrangeStainedGlassPaneData { - pub east: bool, - pub west: bool, + pub north: bool, pub south: bool, + pub west: bool, pub waterlogged: bool, - pub north: bool, + pub east: bool, } impl OrangeStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - east: bool::from_snake_case(map.get("east")?)?, - west: bool::from_snake_case(map.get("west")?)?, + north: bool::from_snake_case(map.get("north")?)?, south: bool::from_snake_case(map.get("south")?)?, + west: bool::from_snake_case(map.get("west")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - north: bool::from_snake_case(map.get("north")?)?, + east: bool::from_snake_case(map.get("east")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("north".to_string(), self.north.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("north".to_string(), self.north.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m } } +impl Default for OrangeStainedGlassPaneData { + fn default() -> Self { + Self { + north: false, + south: false, + west: false, + waterlogged: false, + east: false, + } + } +} impl Value for OrangeStainedGlassPaneData { fn value(&self) -> usize { - (self.east.value() * 16usize) - + (self.west.value() * 8usize) - + (self.south.value() * 4usize) + (self.north.value() * 16usize) + + (self.south.value() * 8usize) + + (self.west.value() * 4usize) + (self.waterlogged.value() * 2usize) - + (self.north.value() * 1usize) + + (self.east.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let east = bool::from_value(val / 16usize).unwrap(); - val -= (east.value() - 0usize) * 16usize; - let west = bool::from_value(val / 8usize).unwrap(); - val -= (west.value() - 0usize) * 8usize; - let south = bool::from_value(val / 4usize).unwrap(); - val -= (south.value() - 0usize) * 4usize; + let north = bool::from_value(val / 16usize).unwrap(); + val -= (north.value() - 0usize) * 16usize; + let south = bool::from_value(val / 8usize).unwrap(); + val -= (south.value() - 0usize) * 8usize; + let west = bool::from_value(val / 4usize).unwrap(); + val -= (west.value() - 0usize) * 4usize; let waterlogged = bool::from_value(val / 2usize).unwrap(); val -= (waterlogged.value() - 0usize) * 2usize; - let north = bool::from_value(val / 1usize).unwrap(); - val -= (north.value() - 0usize) * 1usize; + let east = bool::from_value(val / 1usize).unwrap(); + val -= (east.value() - 0usize) * 1usize; Some(Self { - east, - west, + north, south, + west, waterlogged, - north, + east, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct MagentaStainedGlassPaneData { - pub north: bool, pub waterlogged: bool, - pub west: bool, - pub east: bool, pub south: bool, + pub east: bool, + pub west: bool, + pub north: bool, } impl MagentaStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - north: bool::from_snake_case(map.get("north")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - west: bool::from_snake_case(map.get("west")?)?, - east: bool::from_snake_case(map.get("east")?)?, south: bool::from_snake_case(map.get("south")?)?, + east: bool::from_snake_case(map.get("east")?)?, + west: bool::from_snake_case(map.get("west")?)?, + north: bool::from_snake_case(map.get("north")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("north".to_string(), self.north.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("north".to_string(), self.north.to_snake_case()); m } } +impl Default for MagentaStainedGlassPaneData { + fn default() -> Self { + Self { + waterlogged: false, + south: false, + east: false, + west: false, + north: false, + } + } +} impl Value for MagentaStainedGlassPaneData { fn value(&self) -> usize { - (self.north.value() * 16usize) - + (self.waterlogged.value() * 8usize) - + (self.west.value() * 4usize) - + (self.east.value() * 2usize) - + (self.south.value() * 1usize) + (self.waterlogged.value() * 16usize) + + (self.south.value() * 8usize) + + (self.east.value() * 4usize) + + (self.west.value() * 2usize) + + (self.north.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let north = bool::from_value(val / 16usize).unwrap(); - val -= (north.value() - 0usize) * 16usize; - let waterlogged = bool::from_value(val / 8usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 8usize; - let west = bool::from_value(val / 4usize).unwrap(); - val -= (west.value() - 0usize) * 4usize; - let east = bool::from_value(val / 2usize).unwrap(); - val -= (east.value() - 0usize) * 2usize; - let south = bool::from_value(val / 1usize).unwrap(); - val -= (south.value() - 0usize) * 1usize; + let waterlogged = bool::from_value(val / 16usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 16usize; + let south = bool::from_value(val / 8usize).unwrap(); + val -= (south.value() - 0usize) * 8usize; + let east = bool::from_value(val / 4usize).unwrap(); + val -= (east.value() - 0usize) * 4usize; + let west = bool::from_value(val / 2usize).unwrap(); + val -= (west.value() - 0usize) * 2usize; + let north = bool::from_value(val / 1usize).unwrap(); + val -= (north.value() - 0usize) * 1usize; Some(Self { - north, waterlogged, - west, - east, south, + east, + west, + north, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct LightBlueStainedGlassPaneData { pub north: bool, - pub waterlogged: bool, - pub south: bool, - pub east: bool, pub west: bool, + pub east: bool, + pub south: bool, + pub waterlogged: bool, } impl LightBlueStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { north: bool::from_snake_case(map.get("north")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - south: bool::from_snake_case(map.get("south")?)?, - east: bool::from_snake_case(map.get("east")?)?, west: bool::from_snake_case(map.get("west")?)?, + east: bool::from_snake_case(map.get("east")?)?, + south: bool::from_snake_case(map.get("south")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for LightBlueStainedGlassPaneData { + fn default() -> Self { + Self { + north: false, + west: false, + east: false, + south: false, + waterlogged: false, + } + } +} impl Value for LightBlueStainedGlassPaneData { fn value(&self) -> usize { (self.north.value() * 16usize) - + (self.waterlogged.value() * 8usize) - + (self.south.value() * 4usize) - + (self.east.value() * 2usize) - + (self.west.value() * 1usize) + + (self.west.value() * 8usize) + + (self.east.value() * 4usize) + + (self.south.value() * 2usize) + + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -12672,177 +15716,210 @@ impl Value for LightBlueStainedGlassPaneData { } let north = bool::from_value(val / 16usize).unwrap(); val -= (north.value() - 0usize) * 16usize; - let waterlogged = bool::from_value(val / 8usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 8usize; - let south = bool::from_value(val / 4usize).unwrap(); - val -= (south.value() - 0usize) * 4usize; - let east = bool::from_value(val / 2usize).unwrap(); - val -= (east.value() - 0usize) * 2usize; - let west = bool::from_value(val / 1usize).unwrap(); - val -= (west.value() - 0usize) * 1usize; + let west = bool::from_value(val / 8usize).unwrap(); + val -= (west.value() - 0usize) * 8usize; + let east = bool::from_value(val / 4usize).unwrap(); + val -= (east.value() - 0usize) * 4usize; + let south = bool::from_value(val / 2usize).unwrap(); + val -= (south.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { north, - waterlogged, - south, - east, west, + east, + south, + waterlogged, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct YellowStainedGlassPaneData { - pub west: bool, pub waterlogged: bool, + pub west: bool, + pub east: bool, pub north: bool, pub south: bool, - pub east: bool, } impl YellowStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - west: bool::from_snake_case(map.get("west")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + west: bool::from_snake_case(map.get("west")?)?, + east: bool::from_snake_case(map.get("east")?)?, north: bool::from_snake_case(map.get("north")?)?, south: bool::from_snake_case(map.get("south")?)?, - east: bool::from_snake_case(map.get("east")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("west".to_string(), self.west.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); m } } +impl Default for YellowStainedGlassPaneData { + fn default() -> Self { + Self { + waterlogged: false, + west: false, + east: false, + north: false, + south: false, + } + } +} impl Value for YellowStainedGlassPaneData { fn value(&self) -> usize { - (self.west.value() * 16usize) - + (self.waterlogged.value() * 8usize) - + (self.north.value() * 4usize) - + (self.south.value() * 2usize) - + (self.east.value() * 1usize) + (self.waterlogged.value() * 16usize) + + (self.west.value() * 8usize) + + (self.east.value() * 4usize) + + (self.north.value() * 2usize) + + (self.south.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let west = bool::from_value(val / 16usize).unwrap(); - val -= (west.value() - 0usize) * 16usize; - let waterlogged = bool::from_value(val / 8usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 8usize; - let north = bool::from_value(val / 4usize).unwrap(); - val -= (north.value() - 0usize) * 4usize; - let south = bool::from_value(val / 2usize).unwrap(); - val -= (south.value() - 0usize) * 2usize; - let east = bool::from_value(val / 1usize).unwrap(); - val -= (east.value() - 0usize) * 1usize; + let waterlogged = bool::from_value(val / 16usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 16usize; + let west = bool::from_value(val / 8usize).unwrap(); + val -= (west.value() - 0usize) * 8usize; + let east = bool::from_value(val / 4usize).unwrap(); + val -= (east.value() - 0usize) * 4usize; + let north = bool::from_value(val / 2usize).unwrap(); + val -= (north.value() - 0usize) * 2usize; + let south = bool::from_value(val / 1usize).unwrap(); + val -= (south.value() - 0usize) * 1usize; Some(Self { - west, waterlogged, + west, + east, north, south, - east, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct LimeStainedGlassPaneData { + pub east: bool, + pub waterlogged: bool, + pub west: bool, pub north: bool, pub south: bool, - pub west: bool, - pub waterlogged: bool, - pub east: bool, } impl LimeStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + east: bool::from_snake_case(map.get("east")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + west: bool::from_snake_case(map.get("west")?)?, north: bool::from_snake_case(map.get("north")?)?, south: bool::from_snake_case(map.get("south")?)?, - west: bool::from_snake_case(map.get("west")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - east: bool::from_snake_case(map.get("east")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); m } } +impl Default for LimeStainedGlassPaneData { + fn default() -> Self { + Self { + east: false, + waterlogged: false, + west: false, + north: false, + south: false, + } + } +} impl Value for LimeStainedGlassPaneData { fn value(&self) -> usize { - (self.north.value() * 16usize) - + (self.south.value() * 8usize) + (self.east.value() * 16usize) + + (self.waterlogged.value() * 8usize) + (self.west.value() * 4usize) - + (self.waterlogged.value() * 2usize) - + (self.east.value() * 1usize) + + (self.north.value() * 2usize) + + (self.south.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let north = bool::from_value(val / 16usize).unwrap(); - val -= (north.value() - 0usize) * 16usize; - let south = bool::from_value(val / 8usize).unwrap(); - val -= (south.value() - 0usize) * 8usize; + let east = bool::from_value(val / 16usize).unwrap(); + val -= (east.value() - 0usize) * 16usize; + let waterlogged = bool::from_value(val / 8usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 8usize; let west = bool::from_value(val / 4usize).unwrap(); val -= (west.value() - 0usize) * 4usize; - let waterlogged = bool::from_value(val / 2usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 2usize; - let east = bool::from_value(val / 1usize).unwrap(); - val -= (east.value() - 0usize) * 1usize; + let north = bool::from_value(val / 2usize).unwrap(); + val -= (north.value() - 0usize) * 2usize; + let south = bool::from_value(val / 1usize).unwrap(); + val -= (south.value() - 0usize) * 1usize; Some(Self { + east, + waterlogged, + west, north, south, - west, - waterlogged, - east, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct PinkStainedGlassPaneData { - pub east: bool, - pub south: bool, pub waterlogged: bool, pub west: bool, + pub east: bool, + pub south: bool, pub north: bool, } impl PinkStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - east: bool::from_snake_case(map.get("east")?)?, - south: bool::from_snake_case(map.get("south")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, west: bool::from_snake_case(map.get("west")?)?, + east: bool::from_snake_case(map.get("east")?)?, + south: bool::from_snake_case(map.get("south")?)?, north: bool::from_snake_case(map.get("north")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); m } } +impl Default for PinkStainedGlassPaneData { + fn default() -> Self { + Self { + waterlogged: false, + west: false, + east: false, + south: false, + north: false, + } + } +} impl Value for PinkStainedGlassPaneData { fn value(&self) -> usize { - (self.east.value() * 16usize) - + (self.south.value() * 8usize) - + (self.waterlogged.value() * 4usize) - + (self.west.value() * 2usize) + (self.waterlogged.value() * 16usize) + + (self.west.value() * 8usize) + + (self.east.value() * 4usize) + + (self.south.value() * 2usize) + (self.north.value() * 1usize) } #[allow(warnings)] @@ -12850,120 +15927,142 @@ impl Value for PinkStainedGlassPaneData { if val >= 32usize { return None; } - let east = bool::from_value(val / 16usize).unwrap(); - val -= (east.value() - 0usize) * 16usize; - let south = bool::from_value(val / 8usize).unwrap(); - val -= (south.value() - 0usize) * 8usize; - let waterlogged = bool::from_value(val / 4usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 4usize; - let west = bool::from_value(val / 2usize).unwrap(); - val -= (west.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 16usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 16usize; + let west = bool::from_value(val / 8usize).unwrap(); + val -= (west.value() - 0usize) * 8usize; + let east = bool::from_value(val / 4usize).unwrap(); + val -= (east.value() - 0usize) * 4usize; + let south = bool::from_value(val / 2usize).unwrap(); + val -= (south.value() - 0usize) * 2usize; let north = bool::from_value(val / 1usize).unwrap(); val -= (north.value() - 0usize) * 1usize; Some(Self { - east, - south, waterlogged, west, + east, + south, north, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct GrayStainedGlassPaneData { - pub west: bool, pub north: bool, pub east: bool, pub south: bool, pub waterlogged: bool, + pub west: bool, } impl GrayStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - west: bool::from_snake_case(map.get("west")?)?, north: bool::from_snake_case(map.get("north")?)?, east: bool::from_snake_case(map.get("east")?)?, south: bool::from_snake_case(map.get("south")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + west: bool::from_snake_case(map.get("west")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("west".to_string(), self.west.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); m } } +impl Default for GrayStainedGlassPaneData { + fn default() -> Self { + Self { + north: false, + east: false, + south: false, + waterlogged: false, + west: false, + } + } +} impl Value for GrayStainedGlassPaneData { fn value(&self) -> usize { - (self.west.value() * 16usize) - + (self.north.value() * 8usize) - + (self.east.value() * 4usize) - + (self.south.value() * 2usize) - + (self.waterlogged.value() * 1usize) + (self.north.value() * 16usize) + + (self.east.value() * 8usize) + + (self.south.value() * 4usize) + + (self.waterlogged.value() * 2usize) + + (self.west.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let west = bool::from_value(val / 16usize).unwrap(); - val -= (west.value() - 0usize) * 16usize; - let north = bool::from_value(val / 8usize).unwrap(); - val -= (north.value() - 0usize) * 8usize; - let east = bool::from_value(val / 4usize).unwrap(); - val -= (east.value() - 0usize) * 4usize; - let south = bool::from_value(val / 2usize).unwrap(); - val -= (south.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let north = bool::from_value(val / 16usize).unwrap(); + val -= (north.value() - 0usize) * 16usize; + let east = bool::from_value(val / 8usize).unwrap(); + val -= (east.value() - 0usize) * 8usize; + let south = bool::from_value(val / 4usize).unwrap(); + val -= (south.value() - 0usize) * 4usize; + let waterlogged = bool::from_value(val / 2usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 2usize; + let west = bool::from_value(val / 1usize).unwrap(); + val -= (west.value() - 0usize) * 1usize; Some(Self { - west, north, east, south, waterlogged, + west, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct LightGrayStainedGlassPaneData { pub north: bool, - pub south: bool, pub waterlogged: bool, - pub east: bool, pub west: bool, + pub south: bool, + pub east: bool, } impl LightGrayStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { north: bool::from_snake_case(map.get("north")?)?, - south: bool::from_snake_case(map.get("south")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - east: bool::from_snake_case(map.get("east")?)?, west: bool::from_snake_case(map.get("west")?)?, + south: bool::from_snake_case(map.get("south")?)?, + east: bool::from_snake_case(map.get("east")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m } } +impl Default for LightGrayStainedGlassPaneData { + fn default() -> Self { + Self { + north: false, + waterlogged: false, + west: false, + south: false, + east: false, + } + } +} impl Value for LightGrayStainedGlassPaneData { fn value(&self) -> usize { (self.north.value() * 16usize) - + (self.south.value() * 8usize) - + (self.waterlogged.value() * 4usize) - + (self.east.value() * 2usize) - + (self.west.value() * 1usize) + + (self.waterlogged.value() * 8usize) + + (self.west.value() * 4usize) + + (self.south.value() * 2usize) + + (self.east.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -12972,238 +16071,282 @@ impl Value for LightGrayStainedGlassPaneData { } let north = bool::from_value(val / 16usize).unwrap(); val -= (north.value() - 0usize) * 16usize; - let south = bool::from_value(val / 8usize).unwrap(); - val -= (south.value() - 0usize) * 8usize; - let waterlogged = bool::from_value(val / 4usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 4usize; - let east = bool::from_value(val / 2usize).unwrap(); - val -= (east.value() - 0usize) * 2usize; - let west = bool::from_value(val / 1usize).unwrap(); - val -= (west.value() - 0usize) * 1usize; + let waterlogged = bool::from_value(val / 8usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 8usize; + let west = bool::from_value(val / 4usize).unwrap(); + val -= (west.value() - 0usize) * 4usize; + let south = bool::from_value(val / 2usize).unwrap(); + val -= (south.value() - 0usize) * 2usize; + let east = bool::from_value(val / 1usize).unwrap(); + val -= (east.value() - 0usize) * 1usize; Some(Self { north, - south, waterlogged, - east, west, + south, + east, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct CyanStainedGlassPaneData { + pub south: bool, pub east: bool, - pub north: bool, pub west: bool, + pub north: bool, pub waterlogged: bool, - pub south: bool, } impl CyanStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + south: bool::from_snake_case(map.get("south")?)?, east: bool::from_snake_case(map.get("east")?)?, - north: bool::from_snake_case(map.get("north")?)?, west: bool::from_snake_case(map.get("west")?)?, + north: bool::from_snake_case(map.get("north")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - south: bool::from_snake_case(map.get("south")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("south".to_string(), self.south.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("north".to_string(), self.north.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("north".to_string(), self.north.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); m } } +impl Default for CyanStainedGlassPaneData { + fn default() -> Self { + Self { + south: false, + east: false, + west: false, + north: false, + waterlogged: false, + } + } +} impl Value for CyanStainedGlassPaneData { fn value(&self) -> usize { - (self.east.value() * 16usize) - + (self.north.value() * 8usize) + (self.south.value() * 16usize) + + (self.east.value() * 8usize) + (self.west.value() * 4usize) - + (self.waterlogged.value() * 2usize) - + (self.south.value() * 1usize) + + (self.north.value() * 2usize) + + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let east = bool::from_value(val / 16usize).unwrap(); - val -= (east.value() - 0usize) * 16usize; - let north = bool::from_value(val / 8usize).unwrap(); - val -= (north.value() - 0usize) * 8usize; + let south = bool::from_value(val / 16usize).unwrap(); + val -= (south.value() - 0usize) * 16usize; + let east = bool::from_value(val / 8usize).unwrap(); + val -= (east.value() - 0usize) * 8usize; let west = bool::from_value(val / 4usize).unwrap(); val -= (west.value() - 0usize) * 4usize; - let waterlogged = bool::from_value(val / 2usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 2usize; - let south = bool::from_value(val / 1usize).unwrap(); - val -= (south.value() - 0usize) * 1usize; + let north = bool::from_value(val / 2usize).unwrap(); + val -= (north.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { + south, east, - north, west, + north, waterlogged, - south, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct PurpleStainedGlassPaneData { + pub east: bool, pub north: bool, pub waterlogged: bool, pub west: bool, pub south: bool, - pub east: bool, } impl PurpleStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + east: bool::from_snake_case(map.get("east")?)?, north: bool::from_snake_case(map.get("north")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, west: bool::from_snake_case(map.get("west")?)?, south: bool::from_snake_case(map.get("south")?)?, - east: bool::from_snake_case(map.get("east")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("east".to_string(), self.east.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); m } } +impl Default for PurpleStainedGlassPaneData { + fn default() -> Self { + Self { + east: false, + north: false, + waterlogged: false, + west: false, + south: false, + } + } +} impl Value for PurpleStainedGlassPaneData { fn value(&self) -> usize { - (self.north.value() * 16usize) - + (self.waterlogged.value() * 8usize) - + (self.west.value() * 4usize) - + (self.south.value() * 2usize) - + (self.east.value() * 1usize) + (self.east.value() * 16usize) + + (self.north.value() * 8usize) + + (self.waterlogged.value() * 4usize) + + (self.west.value() * 2usize) + + (self.south.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let north = bool::from_value(val / 16usize).unwrap(); - val -= (north.value() - 0usize) * 16usize; - let waterlogged = bool::from_value(val / 8usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 8usize; - let west = bool::from_value(val / 4usize).unwrap(); - val -= (west.value() - 0usize) * 4usize; - let south = bool::from_value(val / 2usize).unwrap(); - val -= (south.value() - 0usize) * 2usize; - let east = bool::from_value(val / 1usize).unwrap(); - val -= (east.value() - 0usize) * 1usize; + let east = bool::from_value(val / 16usize).unwrap(); + val -= (east.value() - 0usize) * 16usize; + let north = bool::from_value(val / 8usize).unwrap(); + val -= (north.value() - 0usize) * 8usize; + let waterlogged = bool::from_value(val / 4usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 4usize; + let west = bool::from_value(val / 2usize).unwrap(); + val -= (west.value() - 0usize) * 2usize; + let south = bool::from_value(val / 1usize).unwrap(); + val -= (south.value() - 0usize) * 1usize; Some(Self { + east, north, waterlogged, west, south, - east, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BlueStainedGlassPaneData { - pub north: bool, pub east: bool, + pub north: bool, + pub west: bool, pub south: bool, pub waterlogged: bool, - pub west: bool, } impl BlueStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - north: bool::from_snake_case(map.get("north")?)?, east: bool::from_snake_case(map.get("east")?)?, + north: bool::from_snake_case(map.get("north")?)?, + west: bool::from_snake_case(map.get("west")?)?, south: bool::from_snake_case(map.get("south")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - west: bool::from_snake_case(map.get("west")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("north".to_string(), self.north.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("north".to_string(), self.north.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); m } } +impl Default for BlueStainedGlassPaneData { + fn default() -> Self { + Self { + east: false, + north: false, + west: false, + south: false, + waterlogged: false, + } + } +} impl Value for BlueStainedGlassPaneData { fn value(&self) -> usize { - (self.north.value() * 16usize) - + (self.east.value() * 8usize) - + (self.south.value() * 4usize) - + (self.waterlogged.value() * 2usize) - + (self.west.value() * 1usize) + (self.east.value() * 16usize) + + (self.north.value() * 8usize) + + (self.west.value() * 4usize) + + (self.south.value() * 2usize) + + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let north = bool::from_value(val / 16usize).unwrap(); - val -= (north.value() - 0usize) * 16usize; - let east = bool::from_value(val / 8usize).unwrap(); - val -= (east.value() - 0usize) * 8usize; - let south = bool::from_value(val / 4usize).unwrap(); - val -= (south.value() - 0usize) * 4usize; - let waterlogged = bool::from_value(val / 2usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 2usize; - let west = bool::from_value(val / 1usize).unwrap(); - val -= (west.value() - 0usize) * 1usize; + let east = bool::from_value(val / 16usize).unwrap(); + val -= (east.value() - 0usize) * 16usize; + let north = bool::from_value(val / 8usize).unwrap(); + val -= (north.value() - 0usize) * 8usize; + let west = bool::from_value(val / 4usize).unwrap(); + val -= (west.value() - 0usize) * 4usize; + let south = bool::from_value(val / 2usize).unwrap(); + val -= (south.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { - north, east, + north, + west, south, waterlogged, - west, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BrownStainedGlassPaneData { pub waterlogged: bool, + pub west: bool, pub east: bool, pub north: bool, pub south: bool, - pub west: bool, } impl BrownStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + west: bool::from_snake_case(map.get("west")?)?, east: bool::from_snake_case(map.get("east")?)?, north: bool::from_snake_case(map.get("north")?)?, south: bool::from_snake_case(map.get("south")?)?, - west: bool::from_snake_case(map.get("west")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); m } } +impl Default for BrownStainedGlassPaneData { + fn default() -> Self { + Self { + waterlogged: false, + west: false, + east: false, + north: false, + south: false, + } + } +} impl Value for BrownStainedGlassPaneData { fn value(&self) -> usize { (self.waterlogged.value() * 16usize) - + (self.east.value() * 8usize) - + (self.north.value() * 4usize) - + (self.south.value() * 2usize) - + (self.west.value() * 1usize) + + (self.west.value() * 8usize) + + (self.east.value() * 4usize) + + (self.north.value() * 2usize) + + (self.south.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -13212,200 +16355,233 @@ impl Value for BrownStainedGlassPaneData { } let waterlogged = bool::from_value(val / 16usize).unwrap(); val -= (waterlogged.value() - 0usize) * 16usize; - let east = bool::from_value(val / 8usize).unwrap(); - val -= (east.value() - 0usize) * 8usize; - let north = bool::from_value(val / 4usize).unwrap(); - val -= (north.value() - 0usize) * 4usize; - let south = bool::from_value(val / 2usize).unwrap(); - val -= (south.value() - 0usize) * 2usize; - let west = bool::from_value(val / 1usize).unwrap(); - val -= (west.value() - 0usize) * 1usize; + let west = bool::from_value(val / 8usize).unwrap(); + val -= (west.value() - 0usize) * 8usize; + let east = bool::from_value(val / 4usize).unwrap(); + val -= (east.value() - 0usize) * 4usize; + let north = bool::from_value(val / 2usize).unwrap(); + val -= (north.value() - 0usize) * 2usize; + let south = bool::from_value(val / 1usize).unwrap(); + val -= (south.value() - 0usize) * 1usize; Some(Self { waterlogged, + west, east, north, south, - west, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct GreenStainedGlassPaneData { - pub north: bool, pub east: bool, - pub west: bool, pub south: bool, pub waterlogged: bool, + pub west: bool, + pub north: bool, } impl GreenStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - north: bool::from_snake_case(map.get("north")?)?, east: bool::from_snake_case(map.get("east")?)?, - west: bool::from_snake_case(map.get("west")?)?, south: bool::from_snake_case(map.get("south")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + west: bool::from_snake_case(map.get("west")?)?, + north: bool::from_snake_case(map.get("north")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("north".to_string(), self.north.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("north".to_string(), self.north.to_snake_case()); m } } +impl Default for GreenStainedGlassPaneData { + fn default() -> Self { + Self { + east: false, + south: false, + waterlogged: false, + west: false, + north: false, + } + } +} impl Value for GreenStainedGlassPaneData { fn value(&self) -> usize { - (self.north.value() * 16usize) - + (self.east.value() * 8usize) - + (self.west.value() * 4usize) - + (self.south.value() * 2usize) - + (self.waterlogged.value() * 1usize) + (self.east.value() * 16usize) + + (self.south.value() * 8usize) + + (self.waterlogged.value() * 4usize) + + (self.west.value() * 2usize) + + (self.north.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let north = bool::from_value(val / 16usize).unwrap(); - val -= (north.value() - 0usize) * 16usize; - let east = bool::from_value(val / 8usize).unwrap(); - val -= (east.value() - 0usize) * 8usize; - let west = bool::from_value(val / 4usize).unwrap(); - val -= (west.value() - 0usize) * 4usize; - let south = bool::from_value(val / 2usize).unwrap(); - val -= (south.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let east = bool::from_value(val / 16usize).unwrap(); + val -= (east.value() - 0usize) * 16usize; + let south = bool::from_value(val / 8usize).unwrap(); + val -= (south.value() - 0usize) * 8usize; + let waterlogged = bool::from_value(val / 4usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 4usize; + let west = bool::from_value(val / 2usize).unwrap(); + val -= (west.value() - 0usize) * 2usize; + let north = bool::from_value(val / 1usize).unwrap(); + val -= (north.value() - 0usize) * 1usize; Some(Self { - north, east, - west, south, waterlogged, + west, + north, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct RedStainedGlassPaneData { + pub east: bool, + pub south: bool, pub north: bool, - pub waterlogged: bool, pub west: bool, - pub south: bool, - pub east: bool, + pub waterlogged: bool, } impl RedStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + east: bool::from_snake_case(map.get("east")?)?, + south: bool::from_snake_case(map.get("south")?)?, north: bool::from_snake_case(map.get("north")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, west: bool::from_snake_case(map.get("west")?)?, - south: bool::from_snake_case(map.get("south")?)?, - east: bool::from_snake_case(map.get("east")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for RedStainedGlassPaneData { + fn default() -> Self { + Self { + east: false, + south: false, + north: false, + west: false, + waterlogged: false, + } + } +} impl Value for RedStainedGlassPaneData { fn value(&self) -> usize { - (self.north.value() * 16usize) - + (self.waterlogged.value() * 8usize) - + (self.west.value() * 4usize) - + (self.south.value() * 2usize) - + (self.east.value() * 1usize) + (self.east.value() * 16usize) + + (self.south.value() * 8usize) + + (self.north.value() * 4usize) + + (self.west.value() * 2usize) + + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let north = bool::from_value(val / 16usize).unwrap(); - val -= (north.value() - 0usize) * 16usize; - let waterlogged = bool::from_value(val / 8usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 8usize; - let west = bool::from_value(val / 4usize).unwrap(); - val -= (west.value() - 0usize) * 4usize; - let south = bool::from_value(val / 2usize).unwrap(); - val -= (south.value() - 0usize) * 2usize; - let east = bool::from_value(val / 1usize).unwrap(); - val -= (east.value() - 0usize) * 1usize; + let east = bool::from_value(val / 16usize).unwrap(); + val -= (east.value() - 0usize) * 16usize; + let south = bool::from_value(val / 8usize).unwrap(); + val -= (south.value() - 0usize) * 8usize; + let north = bool::from_value(val / 4usize).unwrap(); + val -= (north.value() - 0usize) * 4usize; + let west = bool::from_value(val / 2usize).unwrap(); + val -= (west.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { + east, + south, north, - waterlogged, west, - south, - east, + waterlogged, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BlackStainedGlassPaneData { - pub south: bool, - pub north: bool, - pub east: bool, - pub waterlogged: bool, pub west: bool, + pub waterlogged: bool, + pub east: bool, + pub north: bool, + pub south: bool, } impl BlackStainedGlassPaneData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - south: bool::from_snake_case(map.get("south")?)?, - north: bool::from_snake_case(map.get("north")?)?, - east: bool::from_snake_case(map.get("east")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, west: bool::from_snake_case(map.get("west")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + east: bool::from_snake_case(map.get("east")?)?, + north: bool::from_snake_case(map.get("north")?)?, + south: bool::from_snake_case(map.get("south")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("north".to_string(), self.north.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("north".to_string(), self.north.to_snake_case()); + m.insert("south".to_string(), self.south.to_snake_case()); m } } +impl Default for BlackStainedGlassPaneData { + fn default() -> Self { + Self { + west: false, + waterlogged: false, + east: false, + north: false, + south: false, + } + } +} impl Value for BlackStainedGlassPaneData { fn value(&self) -> usize { - (self.south.value() * 16usize) - + (self.north.value() * 8usize) + (self.west.value() * 16usize) + + (self.waterlogged.value() * 8usize) + (self.east.value() * 4usize) - + (self.waterlogged.value() * 2usize) - + (self.west.value() * 1usize) + + (self.north.value() * 2usize) + + (self.south.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let south = bool::from_value(val / 16usize).unwrap(); - val -= (south.value() - 0usize) * 16usize; - let north = bool::from_value(val / 8usize).unwrap(); - val -= (north.value() - 0usize) * 8usize; + let west = bool::from_value(val / 16usize).unwrap(); + val -= (west.value() - 0usize) * 16usize; + let waterlogged = bool::from_value(val / 8usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 8usize; let east = bool::from_value(val / 4usize).unwrap(); val -= (east.value() - 0usize) * 4usize; - let waterlogged = bool::from_value(val / 2usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 2usize; - let west = bool::from_value(val / 1usize).unwrap(); - val -= (west.value() - 0usize) * 1usize; + let north = bool::from_value(val / 2usize).unwrap(); + val -= (north.value() - 0usize) * 2usize; + let south = bool::from_value(val / 1usize).unwrap(); + val -= (south.value() - 0usize) * 1usize; Some(Self { - south, - north, - east, - waterlogged, west, + waterlogged, + east, + north, + south, }) } } @@ -13434,6 +16610,16 @@ impl AcaciaStairsData { m } } +impl Default for AcaciaStairsData { + fn default() -> Self { + Self { + facing: AcaciaStairsFacing::North, + half: AcaciaStairsHalf::Bottom, + shape: AcaciaStairsShape::Straight, + waterlogged: false, + } + } +} impl Value for AcaciaStairsData { fn value(&self) -> usize { (self.facing.value() * 20usize) @@ -13464,254 +16650,305 @@ impl Value for AcaciaStairsData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DarkOakStairsData { - pub waterlogged: bool, - pub shape: DarkOakStairsShape, - pub facing: DarkOakStairsFacing, pub half: DarkOakStairsHalf, + pub facing: DarkOakStairsFacing, + pub shape: DarkOakStairsShape, + pub waterlogged: bool, } impl DarkOakStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - shape: DarkOakStairsShape::from_snake_case(map.get("shape")?)?, - facing: DarkOakStairsFacing::from_snake_case(map.get("facing")?)?, half: DarkOakStairsHalf::from_snake_case(map.get("half")?)?, + facing: DarkOakStairsFacing::from_snake_case(map.get("facing")?)?, + shape: DarkOakStairsShape::from_snake_case(map.get("shape")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("shape".to_string(), self.shape.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("shape".to_string(), self.shape.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for DarkOakStairsData { + fn default() -> Self { + Self { + half: DarkOakStairsHalf::Bottom, + facing: DarkOakStairsFacing::North, + shape: DarkOakStairsShape::Straight, + waterlogged: false, + } + } +} impl Value for DarkOakStairsData { fn value(&self) -> usize { - (self.waterlogged.value() * 40usize) - + (self.shape.value() * 8usize) - + (self.facing.value() * 2usize) - + (self.half.value() * 1usize) + (self.half.value() * 40usize) + + (self.facing.value() * 10usize) + + (self.shape.value() * 2usize) + + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 80usize { return None; } - let waterlogged = bool::from_value(val / 40usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 40usize; - let shape = DarkOakStairsShape::from_value(val / 8usize).unwrap(); - val -= (shape.value() - 0usize) * 8usize; - let facing = DarkOakStairsFacing::from_value(val / 2usize).unwrap(); - val -= (facing.value() - 0usize) * 2usize; - let half = DarkOakStairsHalf::from_value(val / 1usize).unwrap(); - val -= (half.value() - 0usize) * 1usize; - Some(Self { - waterlogged, - shape, - facing, + let half = DarkOakStairsHalf::from_value(val / 40usize).unwrap(); + val -= (half.value() - 0usize) * 40usize; + let facing = DarkOakStairsFacing::from_value(val / 10usize).unwrap(); + val -= (facing.value() - 0usize) * 10usize; + let shape = DarkOakStairsShape::from_value(val / 2usize).unwrap(); + val -= (shape.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; + Some(Self { half, + facing, + shape, + waterlogged, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct IronTrapdoorData { - pub powered: bool, pub facing: IronTrapdoorFacing, pub half: IronTrapdoorHalf, - pub waterlogged: bool, pub open: bool, + pub waterlogged: bool, + pub powered: bool, } impl IronTrapdoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - powered: bool::from_snake_case(map.get("powered")?)?, facing: IronTrapdoorFacing::from_snake_case(map.get("facing")?)?, half: IronTrapdoorHalf::from_snake_case(map.get("half")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, open: bool::from_snake_case(map.get("open")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for IronTrapdoorData { + fn default() -> Self { + Self { + facing: IronTrapdoorFacing::North, + half: IronTrapdoorHalf::Bottom, + open: false, + waterlogged: false, + powered: false, + } + } +} impl Value for IronTrapdoorData { fn value(&self) -> usize { - (self.powered.value() * 32usize) - + (self.facing.value() * 8usize) - + (self.half.value() * 4usize) + (self.facing.value() * 16usize) + + (self.half.value() * 8usize) + + (self.open.value() * 4usize) + (self.waterlogged.value() * 2usize) - + (self.open.value() * 1usize) + + (self.powered.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 64usize { return None; } - let powered = bool::from_value(val / 32usize).unwrap(); - val -= (powered.value() - 0usize) * 32usize; - let facing = IronTrapdoorFacing::from_value(val / 8usize).unwrap(); - val -= (facing.value() - 0usize) * 8usize; - let half = IronTrapdoorHalf::from_value(val / 4usize).unwrap(); - val -= (half.value() - 0usize) * 4usize; + let facing = IronTrapdoorFacing::from_value(val / 16usize).unwrap(); + val -= (facing.value() - 0usize) * 16usize; + let half = IronTrapdoorHalf::from_value(val / 8usize).unwrap(); + val -= (half.value() - 0usize) * 8usize; + let open = bool::from_value(val / 4usize).unwrap(); + val -= (open.value() - 0usize) * 4usize; let waterlogged = bool::from_value(val / 2usize).unwrap(); val -= (waterlogged.value() - 0usize) * 2usize; - let open = bool::from_value(val / 1usize).unwrap(); - val -= (open.value() - 0usize) * 1usize; + let powered = bool::from_value(val / 1usize).unwrap(); + val -= (powered.value() - 0usize) * 1usize; Some(Self { - powered, facing, half, - waterlogged, open, + waterlogged, + powered, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct PrismarineStairsData { + pub waterlogged: bool, pub half: PrismarineStairsHalf, - pub shape: PrismarineStairsShape, pub facing: PrismarineStairsFacing, - pub waterlogged: bool, + pub shape: PrismarineStairsShape, } impl PrismarineStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, half: PrismarineStairsHalf::from_snake_case(map.get("half")?)?, - shape: PrismarineStairsShape::from_snake_case(map.get("shape")?)?, facing: PrismarineStairsFacing::from_snake_case(map.get("facing")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + shape: PrismarineStairsShape::from_snake_case(map.get("shape")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); - m.insert("shape".to_string(), self.shape.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("shape".to_string(), self.shape.to_snake_case()); m } } +impl Default for PrismarineStairsData { + fn default() -> Self { + Self { + waterlogged: false, + half: PrismarineStairsHalf::Bottom, + facing: PrismarineStairsFacing::North, + shape: PrismarineStairsShape::Straight, + } + } +} impl Value for PrismarineStairsData { fn value(&self) -> usize { - (self.half.value() * 40usize) - + (self.shape.value() * 8usize) - + (self.facing.value() * 2usize) - + (self.waterlogged.value() * 1usize) + (self.waterlogged.value() * 40usize) + + (self.half.value() * 20usize) + + (self.facing.value() * 5usize) + + (self.shape.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 80usize { return None; } - let half = PrismarineStairsHalf::from_value(val / 40usize).unwrap(); - val -= (half.value() - 0usize) * 40usize; - let shape = PrismarineStairsShape::from_value(val / 8usize).unwrap(); - val -= (shape.value() - 0usize) * 8usize; - let facing = PrismarineStairsFacing::from_value(val / 2usize).unwrap(); - val -= (facing.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let waterlogged = bool::from_value(val / 40usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 40usize; + let half = PrismarineStairsHalf::from_value(val / 20usize).unwrap(); + val -= (half.value() - 0usize) * 20usize; + let facing = PrismarineStairsFacing::from_value(val / 5usize).unwrap(); + val -= (facing.value() - 0usize) * 5usize; + let shape = PrismarineStairsShape::from_value(val / 1usize).unwrap(); + val -= (shape.value() - 0usize) * 1usize; Some(Self { + waterlogged, half, - shape, facing, - waterlogged, + shape, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct PrismarineBrickStairsData { + pub facing: PrismarineBrickStairsFacing, + pub waterlogged: bool, pub half: PrismarineBrickStairsHalf, pub shape: PrismarineBrickStairsShape, - pub waterlogged: bool, - pub facing: PrismarineBrickStairsFacing, } impl PrismarineBrickStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + facing: PrismarineBrickStairsFacing::from_snake_case(map.get("facing")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, half: PrismarineBrickStairsHalf::from_snake_case(map.get("half")?)?, shape: PrismarineBrickStairsShape::from_snake_case(map.get("shape")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - facing: PrismarineBrickStairsFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for PrismarineBrickStairsData { + fn default() -> Self { + Self { + facing: PrismarineBrickStairsFacing::North, + waterlogged: false, + half: PrismarineBrickStairsHalf::Bottom, + shape: PrismarineBrickStairsShape::Straight, + } + } +} impl Value for PrismarineBrickStairsData { fn value(&self) -> usize { - (self.half.value() * 40usize) - + (self.shape.value() * 8usize) - + (self.waterlogged.value() * 4usize) - + (self.facing.value() * 1usize) + (self.facing.value() * 20usize) + + (self.waterlogged.value() * 10usize) + + (self.half.value() * 5usize) + + (self.shape.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 80usize { return None; } - let half = PrismarineBrickStairsHalf::from_value(val / 40usize).unwrap(); - val -= (half.value() - 0usize) * 40usize; - let shape = PrismarineBrickStairsShape::from_value(val / 8usize).unwrap(); - val -= (shape.value() - 0usize) * 8usize; - let waterlogged = bool::from_value(val / 4usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 4usize; - let facing = PrismarineBrickStairsFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let facing = PrismarineBrickStairsFacing::from_value(val / 20usize).unwrap(); + val -= (facing.value() - 0usize) * 20usize; + let waterlogged = bool::from_value(val / 10usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 10usize; + let half = PrismarineBrickStairsHalf::from_value(val / 5usize).unwrap(); + val -= (half.value() - 0usize) * 5usize; + let shape = PrismarineBrickStairsShape::from_value(val / 1usize).unwrap(); + val -= (shape.value() - 0usize) * 1usize; Some(Self { + facing, + waterlogged, half, shape, - waterlogged, - facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DarkPrismarineStairsData { pub half: DarkPrismarineStairsHalf, - pub facing: DarkPrismarineStairsFacing, - pub waterlogged: bool, pub shape: DarkPrismarineStairsShape, + pub waterlogged: bool, + pub facing: DarkPrismarineStairsFacing, } impl DarkPrismarineStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { half: DarkPrismarineStairsHalf::from_snake_case(map.get("half")?)?, - facing: DarkPrismarineStairsFacing::from_snake_case(map.get("facing")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, shape: DarkPrismarineStairsShape::from_snake_case(map.get("shape")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + facing: DarkPrismarineStairsFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("half".to_string(), self.half.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for DarkPrismarineStairsData { + fn default() -> Self { + Self { + half: DarkPrismarineStairsHalf::Bottom, + shape: DarkPrismarineStairsShape::Straight, + waterlogged: false, + facing: DarkPrismarineStairsFacing::North, + } + } +} impl Value for DarkPrismarineStairsData { fn value(&self) -> usize { (self.half.value() * 40usize) - + (self.facing.value() * 10usize) - + (self.waterlogged.value() * 5usize) - + (self.shape.value() * 1usize) + + (self.shape.value() * 8usize) + + (self.waterlogged.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -13720,53 +16957,61 @@ impl Value for DarkPrismarineStairsData { } let half = DarkPrismarineStairsHalf::from_value(val / 40usize).unwrap(); val -= (half.value() - 0usize) * 40usize; - let facing = DarkPrismarineStairsFacing::from_value(val / 10usize).unwrap(); - val -= (facing.value() - 0usize) * 10usize; - let waterlogged = bool::from_value(val / 5usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 5usize; - let shape = DarkPrismarineStairsShape::from_value(val / 1usize).unwrap(); - val -= (shape.value() - 0usize) * 1usize; + let shape = DarkPrismarineStairsShape::from_value(val / 8usize).unwrap(); + val -= (shape.value() - 0usize) * 8usize; + let waterlogged = bool::from_value(val / 4usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 4usize; + let facing = DarkPrismarineStairsFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { half, - facing, - waterlogged, shape, + waterlogged, + facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct PrismarineSlabData { - pub ty: PrismarineSlabType, pub waterlogged: bool, + pub ty: PrismarineSlabType, } impl PrismarineSlabData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - ty: PrismarineSlabType::from_snake_case(map.get("type")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + ty: PrismarineSlabType::from_snake_case(map.get("type")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("type".to_string(), self.ty.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("type".to_string(), self.ty.to_snake_case()); m } } +impl Default for PrismarineSlabData { + fn default() -> Self { + Self { + waterlogged: false, + ty: PrismarineSlabType::Bottom, + } + } +} impl Value for PrismarineSlabData { fn value(&self) -> usize { - (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) + (self.waterlogged.value() * 3usize) + (self.ty.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 6usize { return None; } - let ty = PrismarineSlabType::from_value(val / 2usize).unwrap(); - val -= (ty.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; - Some(Self { ty, waterlogged }) + let waterlogged = bool::from_value(val / 3usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 3usize; + let ty = PrismarineSlabType::from_value(val / 1usize).unwrap(); + val -= (ty.value() - 0usize) * 1usize; + Some(Self { waterlogged, ty }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] @@ -13788,6 +17033,14 @@ impl PrismarineBrickSlabData { m } } +impl Default for PrismarineBrickSlabData { + fn default() -> Self { + Self { + ty: PrismarineBrickSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for PrismarineBrickSlabData { fn value(&self) -> usize { (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -13806,37 +17059,45 @@ impl Value for PrismarineBrickSlabData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DarkPrismarineSlabData { - pub waterlogged: bool, pub ty: DarkPrismarineSlabType, + pub waterlogged: bool, } impl DarkPrismarineSlabData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, ty: DarkPrismarineSlabType::from_snake_case(map.get("type")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("type".to_string(), self.ty.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for DarkPrismarineSlabData { + fn default() -> Self { + Self { + ty: DarkPrismarineSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for DarkPrismarineSlabData { fn value(&self) -> usize { - (self.waterlogged.value() * 3usize) + (self.ty.value() * 1usize) + (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 6usize { return None; } - let waterlogged = bool::from_value(val / 3usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 3usize; - let ty = DarkPrismarineSlabType::from_value(val / 1usize).unwrap(); - val -= (ty.value() - 0usize) * 1usize; - Some(Self { waterlogged, ty }) + let ty = DarkPrismarineSlabType::from_value(val / 2usize).unwrap(); + val -= (ty.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; + Some(Self { ty, waterlogged }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] @@ -13855,6 +17116,13 @@ impl HayBlockData { m } } +impl Default for HayBlockData { + fn default() -> Self { + Self { + axis: HayBlockAxis::Y, + } + } +} impl Value for HayBlockData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -13885,6 +17153,13 @@ impl SunflowerData { m } } +impl Default for SunflowerData { + fn default() -> Self { + Self { + half: SunflowerHalf::Lower, + } + } +} impl Value for SunflowerData { fn value(&self) -> usize { (self.half.value() * 1usize) @@ -13915,6 +17190,13 @@ impl LilacData { m } } +impl Default for LilacData { + fn default() -> Self { + Self { + half: LilacHalf::Lower, + } + } +} impl Value for LilacData { fn value(&self) -> usize { (self.half.value() * 1usize) @@ -13945,6 +17227,13 @@ impl RoseBushData { m } } +impl Default for RoseBushData { + fn default() -> Self { + Self { + half: RoseBushHalf::Lower, + } + } +} impl Value for RoseBushData { fn value(&self) -> usize { (self.half.value() * 1usize) @@ -13975,6 +17264,13 @@ impl PeonyData { m } } +impl Default for PeonyData { + fn default() -> Self { + Self { + half: PeonyHalf::Lower, + } + } +} impl Value for PeonyData { fn value(&self) -> usize { (self.half.value() * 1usize) @@ -14005,6 +17301,13 @@ impl TallGrassData { m } } +impl Default for TallGrassData { + fn default() -> Self { + Self { + half: TallGrassHalf::Lower, + } + } +} impl Value for TallGrassData { fn value(&self) -> usize { (self.half.value() * 1usize) @@ -14035,6 +17338,13 @@ impl LargeFernData { m } } +impl Default for LargeFernData { + fn default() -> Self { + Self { + half: LargeFernHalf::Lower, + } + } +} impl Value for LargeFernData { fn value(&self) -> usize { (self.half.value() * 1usize) @@ -14065,6 +17375,11 @@ impl WhiteBannerData { m } } +impl Default for WhiteBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for WhiteBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14095,6 +17410,11 @@ impl OrangeBannerData { m } } +impl Default for OrangeBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for OrangeBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14125,6 +17445,11 @@ impl MagentaBannerData { m } } +impl Default for MagentaBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for MagentaBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14155,6 +17480,11 @@ impl LightBlueBannerData { m } } +impl Default for LightBlueBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for LightBlueBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14185,6 +17515,11 @@ impl YellowBannerData { m } } +impl Default for YellowBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for YellowBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14215,6 +17550,11 @@ impl LimeBannerData { m } } +impl Default for LimeBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for LimeBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14245,6 +17585,11 @@ impl PinkBannerData { m } } +impl Default for PinkBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for PinkBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14275,6 +17620,11 @@ impl GrayBannerData { m } } +impl Default for GrayBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for GrayBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14305,6 +17655,11 @@ impl LightGrayBannerData { m } } +impl Default for LightGrayBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for LightGrayBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14335,6 +17690,11 @@ impl CyanBannerData { m } } +impl Default for CyanBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for CyanBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14365,6 +17725,11 @@ impl PurpleBannerData { m } } +impl Default for PurpleBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for PurpleBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14395,6 +17760,11 @@ impl BlueBannerData { m } } +impl Default for BlueBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for BlueBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14425,6 +17795,11 @@ impl BrownBannerData { m } } +impl Default for BrownBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for BrownBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14455,6 +17830,11 @@ impl GreenBannerData { m } } +impl Default for GreenBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for GreenBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14485,6 +17865,11 @@ impl RedBannerData { m } } +impl Default for RedBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for RedBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14515,6 +17900,11 @@ impl BlackBannerData { m } } +impl Default for BlackBannerData { + fn default() -> Self { + Self { rotation: 0 } + } +} impl Value for BlackBannerData { fn value(&self) -> usize { (self.rotation.value() * 1usize) @@ -14545,6 +17935,13 @@ impl WhiteWallBannerData { m } } +impl Default for WhiteWallBannerData { + fn default() -> Self { + Self { + facing: WhiteWallBannerFacing::North, + } + } +} impl Value for WhiteWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14575,6 +17972,13 @@ impl OrangeWallBannerData { m } } +impl Default for OrangeWallBannerData { + fn default() -> Self { + Self { + facing: OrangeWallBannerFacing::North, + } + } +} impl Value for OrangeWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14605,6 +18009,13 @@ impl MagentaWallBannerData { m } } +impl Default for MagentaWallBannerData { + fn default() -> Self { + Self { + facing: MagentaWallBannerFacing::North, + } + } +} impl Value for MagentaWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14635,6 +18046,13 @@ impl LightBlueWallBannerData { m } } +impl Default for LightBlueWallBannerData { + fn default() -> Self { + Self { + facing: LightBlueWallBannerFacing::North, + } + } +} impl Value for LightBlueWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14665,6 +18083,13 @@ impl YellowWallBannerData { m } } +impl Default for YellowWallBannerData { + fn default() -> Self { + Self { + facing: YellowWallBannerFacing::North, + } + } +} impl Value for YellowWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14695,6 +18120,13 @@ impl LimeWallBannerData { m } } +impl Default for LimeWallBannerData { + fn default() -> Self { + Self { + facing: LimeWallBannerFacing::North, + } + } +} impl Value for LimeWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14725,6 +18157,13 @@ impl PinkWallBannerData { m } } +impl Default for PinkWallBannerData { + fn default() -> Self { + Self { + facing: PinkWallBannerFacing::North, + } + } +} impl Value for PinkWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14755,6 +18194,13 @@ impl GrayWallBannerData { m } } +impl Default for GrayWallBannerData { + fn default() -> Self { + Self { + facing: GrayWallBannerFacing::North, + } + } +} impl Value for GrayWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14785,6 +18231,13 @@ impl LightGrayWallBannerData { m } } +impl Default for LightGrayWallBannerData { + fn default() -> Self { + Self { + facing: LightGrayWallBannerFacing::North, + } + } +} impl Value for LightGrayWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14815,6 +18268,13 @@ impl CyanWallBannerData { m } } +impl Default for CyanWallBannerData { + fn default() -> Self { + Self { + facing: CyanWallBannerFacing::North, + } + } +} impl Value for CyanWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14845,6 +18305,13 @@ impl PurpleWallBannerData { m } } +impl Default for PurpleWallBannerData { + fn default() -> Self { + Self { + facing: PurpleWallBannerFacing::North, + } + } +} impl Value for PurpleWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14875,6 +18342,13 @@ impl BlueWallBannerData { m } } +impl Default for BlueWallBannerData { + fn default() -> Self { + Self { + facing: BlueWallBannerFacing::North, + } + } +} impl Value for BlueWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14905,6 +18379,13 @@ impl BrownWallBannerData { m } } +impl Default for BrownWallBannerData { + fn default() -> Self { + Self { + facing: BrownWallBannerFacing::North, + } + } +} impl Value for BrownWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14935,6 +18416,13 @@ impl GreenWallBannerData { m } } +impl Default for GreenWallBannerData { + fn default() -> Self { + Self { + facing: GreenWallBannerFacing::North, + } + } +} impl Value for GreenWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14965,6 +18453,13 @@ impl RedWallBannerData { m } } +impl Default for RedWallBannerData { + fn default() -> Self { + Self { + facing: RedWallBannerFacing::North, + } + } +} impl Value for RedWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -14995,6 +18490,13 @@ impl BlackWallBannerData { m } } +impl Default for BlackWallBannerData { + fn default() -> Self { + Self { + facing: BlackWallBannerFacing::North, + } + } +} impl Value for BlackWallBannerData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -15011,90 +18513,108 @@ impl Value for BlackWallBannerData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct RedSandstoneStairsData { - pub waterlogged: bool, - pub half: RedSandstoneStairsHalf, pub shape: RedSandstoneStairsShape, + pub half: RedSandstoneStairsHalf, pub facing: RedSandstoneStairsFacing, + pub waterlogged: bool, } impl RedSandstoneStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - half: RedSandstoneStairsHalf::from_snake_case(map.get("half")?)?, shape: RedSandstoneStairsShape::from_snake_case(map.get("shape")?)?, + half: RedSandstoneStairsHalf::from_snake_case(map.get("half")?)?, facing: RedSandstoneStairsFacing::from_snake_case(map.get("facing")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); m.insert("shape".to_string(), self.shape.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for RedSandstoneStairsData { + fn default() -> Self { + Self { + shape: RedSandstoneStairsShape::Straight, + half: RedSandstoneStairsHalf::Bottom, + facing: RedSandstoneStairsFacing::North, + waterlogged: false, + } + } +} impl Value for RedSandstoneStairsData { fn value(&self) -> usize { - (self.waterlogged.value() * 40usize) - + (self.half.value() * 20usize) - + (self.shape.value() * 4usize) - + (self.facing.value() * 1usize) + (self.shape.value() * 16usize) + + (self.half.value() * 8usize) + + (self.facing.value() * 2usize) + + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 80usize { return None; } - let waterlogged = bool::from_value(val / 40usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 40usize; - let half = RedSandstoneStairsHalf::from_value(val / 20usize).unwrap(); - val -= (half.value() - 0usize) * 20usize; - let shape = RedSandstoneStairsShape::from_value(val / 4usize).unwrap(); - val -= (shape.value() - 0usize) * 4usize; - let facing = RedSandstoneStairsFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let shape = RedSandstoneStairsShape::from_value(val / 16usize).unwrap(); + val -= (shape.value() - 0usize) * 16usize; + let half = RedSandstoneStairsHalf::from_value(val / 8usize).unwrap(); + val -= (half.value() - 0usize) * 8usize; + let facing = RedSandstoneStairsFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { - waterlogged, - half, shape, + half, facing, + waterlogged, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct OakSlabData { - pub ty: OakSlabType, pub waterlogged: bool, + pub ty: OakSlabType, } impl OakSlabData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - ty: OakSlabType::from_snake_case(map.get("type")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + ty: OakSlabType::from_snake_case(map.get("type")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("type".to_string(), self.ty.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("type".to_string(), self.ty.to_snake_case()); m } } +impl Default for OakSlabData { + fn default() -> Self { + Self { + waterlogged: false, + ty: OakSlabType::Bottom, + } + } +} impl Value for OakSlabData { fn value(&self) -> usize { - (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) + (self.waterlogged.value() * 3usize) + (self.ty.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 6usize { return None; } - let ty = OakSlabType::from_value(val / 2usize).unwrap(); - val -= (ty.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; - Some(Self { ty, waterlogged }) + let waterlogged = bool::from_value(val / 3usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 3usize; + let ty = OakSlabType::from_value(val / 1usize).unwrap(); + val -= (ty.value() - 0usize) * 1usize; + Some(Self { waterlogged, ty }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] @@ -15116,6 +18636,14 @@ impl SpruceSlabData { m } } +impl Default for SpruceSlabData { + fn default() -> Self { + Self { + ty: SpruceSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for SpruceSlabData { fn value(&self) -> usize { (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -15151,6 +18679,14 @@ impl BirchSlabData { m } } +impl Default for BirchSlabData { + fn default() -> Self { + Self { + waterlogged: false, + ty: BirchSlabType::Bottom, + } + } +} impl Value for BirchSlabData { fn value(&self) -> usize { (self.waterlogged.value() * 3usize) + (self.ty.value() * 1usize) @@ -15169,142 +18705,174 @@ impl Value for BirchSlabData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct JungleSlabData { - pub waterlogged: bool, pub ty: JungleSlabType, + pub waterlogged: bool, } impl JungleSlabData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, ty: JungleSlabType::from_snake_case(map.get("type")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("type".to_string(), self.ty.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for JungleSlabData { + fn default() -> Self { + Self { + ty: JungleSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for JungleSlabData { fn value(&self) -> usize { - (self.waterlogged.value() * 3usize) + (self.ty.value() * 1usize) + (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 6usize { return None; } - let waterlogged = bool::from_value(val / 3usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 3usize; - let ty = JungleSlabType::from_value(val / 1usize).unwrap(); - val -= (ty.value() - 0usize) * 1usize; - Some(Self { waterlogged, ty }) + let ty = JungleSlabType::from_value(val / 2usize).unwrap(); + val -= (ty.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; + Some(Self { ty, waterlogged }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct AcaciaSlabData { - pub waterlogged: bool, pub ty: AcaciaSlabType, + pub waterlogged: bool, } impl AcaciaSlabData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, ty: AcaciaSlabType::from_snake_case(map.get("type")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("type".to_string(), self.ty.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for AcaciaSlabData { + fn default() -> Self { + Self { + ty: AcaciaSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for AcaciaSlabData { fn value(&self) -> usize { - (self.waterlogged.value() * 3usize) + (self.ty.value() * 1usize) + (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 6usize { return None; } - let waterlogged = bool::from_value(val / 3usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 3usize; - let ty = AcaciaSlabType::from_value(val / 1usize).unwrap(); - val -= (ty.value() - 0usize) * 1usize; - Some(Self { waterlogged, ty }) + let ty = AcaciaSlabType::from_value(val / 2usize).unwrap(); + val -= (ty.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; + Some(Self { ty, waterlogged }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DarkOakSlabData { - pub ty: DarkOakSlabType, pub waterlogged: bool, + pub ty: DarkOakSlabType, } impl DarkOakSlabData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - ty: DarkOakSlabType::from_snake_case(map.get("type")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + ty: DarkOakSlabType::from_snake_case(map.get("type")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("type".to_string(), self.ty.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("type".to_string(), self.ty.to_snake_case()); m } } +impl Default for DarkOakSlabData { + fn default() -> Self { + Self { + waterlogged: false, + ty: DarkOakSlabType::Bottom, + } + } +} impl Value for DarkOakSlabData { fn value(&self) -> usize { - (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) + (self.waterlogged.value() * 3usize) + (self.ty.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 6usize { return None; } - let ty = DarkOakSlabType::from_value(val / 2usize).unwrap(); - val -= (ty.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; - Some(Self { ty, waterlogged }) + let waterlogged = bool::from_value(val / 3usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 3usize; + let ty = DarkOakSlabType::from_value(val / 1usize).unwrap(); + val -= (ty.value() - 0usize) * 1usize; + Some(Self { waterlogged, ty }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct StoneSlabData { - pub waterlogged: bool, pub ty: StoneSlabType, + pub waterlogged: bool, } impl StoneSlabData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, ty: StoneSlabType::from_snake_case(map.get("type")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("type".to_string(), self.ty.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for StoneSlabData { + fn default() -> Self { + Self { + ty: StoneSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for StoneSlabData { fn value(&self) -> usize { - (self.waterlogged.value() * 3usize) + (self.ty.value() * 1usize) + (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 6usize { return None; } - let waterlogged = bool::from_value(val / 3usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 3usize; - let ty = StoneSlabType::from_value(val / 1usize).unwrap(); - val -= (ty.value() - 0usize) * 1usize; - Some(Self { waterlogged, ty }) + let ty = StoneSlabType::from_value(val / 2usize).unwrap(); + val -= (ty.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; + Some(Self { ty, waterlogged }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] @@ -15326,6 +18894,14 @@ impl SandstoneSlabData { m } } +impl Default for SandstoneSlabData { + fn default() -> Self { + Self { + ty: SandstoneSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for SandstoneSlabData { fn value(&self) -> usize { (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -15361,6 +18937,14 @@ impl PetrifiedOakSlabData { m } } +impl Default for PetrifiedOakSlabData { + fn default() -> Self { + Self { + ty: PetrifiedOakSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for PetrifiedOakSlabData { fn value(&self) -> usize { (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -15396,6 +18980,14 @@ impl CobblestoneSlabData { m } } +impl Default for CobblestoneSlabData { + fn default() -> Self { + Self { + ty: CobblestoneSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for CobblestoneSlabData { fn value(&self) -> usize { (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -15431,6 +19023,14 @@ impl BrickSlabData { m } } +impl Default for BrickSlabData { + fn default() -> Self { + Self { + ty: BrickSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for BrickSlabData { fn value(&self) -> usize { (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -15466,6 +19066,14 @@ impl StoneBrickSlabData { m } } +impl Default for StoneBrickSlabData { + fn default() -> Self { + Self { + waterlogged: false, + ty: StoneBrickSlabType::Bottom, + } + } +} impl Value for StoneBrickSlabData { fn value(&self) -> usize { (self.waterlogged.value() * 3usize) + (self.ty.value() * 1usize) @@ -15501,6 +19109,14 @@ impl NetherBrickSlabData { m } } +impl Default for NetherBrickSlabData { + fn default() -> Self { + Self { + ty: NetherBrickSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for NetherBrickSlabData { fn value(&self) -> usize { (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -15519,72 +19135,88 @@ impl Value for NetherBrickSlabData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct QuartzSlabData { - pub waterlogged: bool, pub ty: QuartzSlabType, + pub waterlogged: bool, } impl QuartzSlabData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, ty: QuartzSlabType::from_snake_case(map.get("type")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("type".to_string(), self.ty.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for QuartzSlabData { + fn default() -> Self { + Self { + ty: QuartzSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for QuartzSlabData { fn value(&self) -> usize { - (self.waterlogged.value() * 3usize) + (self.ty.value() * 1usize) + (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 6usize { return None; } - let waterlogged = bool::from_value(val / 3usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 3usize; - let ty = QuartzSlabType::from_value(val / 1usize).unwrap(); - val -= (ty.value() - 0usize) * 1usize; - Some(Self { waterlogged, ty }) + let ty = QuartzSlabType::from_value(val / 2usize).unwrap(); + val -= (ty.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; + Some(Self { ty, waterlogged }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct RedSandstoneSlabData { - pub ty: RedSandstoneSlabType, pub waterlogged: bool, + pub ty: RedSandstoneSlabType, } impl RedSandstoneSlabData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - ty: RedSandstoneSlabType::from_snake_case(map.get("type")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + ty: RedSandstoneSlabType::from_snake_case(map.get("type")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("type".to_string(), self.ty.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("type".to_string(), self.ty.to_snake_case()); m } } +impl Default for RedSandstoneSlabData { + fn default() -> Self { + Self { + waterlogged: false, + ty: RedSandstoneSlabType::Bottom, + } + } +} impl Value for RedSandstoneSlabData { fn value(&self) -> usize { - (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) + (self.waterlogged.value() * 3usize) + (self.ty.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 6usize { return None; } - let ty = RedSandstoneSlabType::from_value(val / 2usize).unwrap(); - val -= (ty.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; - Some(Self { ty, waterlogged }) + let waterlogged = bool::from_value(val / 3usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 3usize; + let ty = RedSandstoneSlabType::from_value(val / 1usize).unwrap(); + val -= (ty.value() - 0usize) * 1usize; + Some(Self { waterlogged, ty }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] @@ -15606,6 +19238,14 @@ impl PurpurSlabData { m } } +impl Default for PurpurSlabData { + fn default() -> Self { + Self { + ty: PurpurSlabType::Bottom, + waterlogged: false, + } + } +} impl Value for PurpurSlabData { fn value(&self) -> usize { (self.ty.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -15624,141 +19264,171 @@ impl Value for PurpurSlabData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct SpruceFenceGateData { - pub in_wall: bool, + pub powered: bool, pub open: bool, pub facing: SpruceFenceGateFacing, - pub powered: bool, + pub in_wall: bool, } impl SpruceFenceGateData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - in_wall: bool::from_snake_case(map.get("in_wall")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, open: bool::from_snake_case(map.get("open")?)?, facing: SpruceFenceGateFacing::from_snake_case(map.get("facing")?)?, - powered: bool::from_snake_case(map.get("powered")?)?, + in_wall: bool::from_snake_case(map.get("in_wall")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("in_wall".to_string(), self.in_wall.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("powered".to_string(), self.powered.to_snake_case()); + m.insert("in_wall".to_string(), self.in_wall.to_snake_case()); m } } +impl Default for SpruceFenceGateData { + fn default() -> Self { + Self { + powered: false, + open: false, + facing: SpruceFenceGateFacing::North, + in_wall: false, + } + } +} impl Value for SpruceFenceGateData { fn value(&self) -> usize { - (self.in_wall.value() * 16usize) + (self.powered.value() * 16usize) + (self.open.value() * 8usize) + (self.facing.value() * 2usize) - + (self.powered.value() * 1usize) + + (self.in_wall.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let in_wall = bool::from_value(val / 16usize).unwrap(); - val -= (in_wall.value() - 0usize) * 16usize; + let powered = bool::from_value(val / 16usize).unwrap(); + val -= (powered.value() - 0usize) * 16usize; let open = bool::from_value(val / 8usize).unwrap(); val -= (open.value() - 0usize) * 8usize; let facing = SpruceFenceGateFacing::from_value(val / 2usize).unwrap(); val -= (facing.value() - 0usize) * 2usize; - let powered = bool::from_value(val / 1usize).unwrap(); - val -= (powered.value() - 0usize) * 1usize; + let in_wall = bool::from_value(val / 1usize).unwrap(); + val -= (in_wall.value() - 0usize) * 1usize; Some(Self { - in_wall, + powered, open, facing, - powered, + in_wall, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] -pub struct BirchFenceGateData { - pub powered: bool, - pub facing: BirchFenceGateFacing, +pub struct BirchFenceGateData { pub in_wall: bool, pub open: bool, + pub facing: BirchFenceGateFacing, + pub powered: bool, } impl BirchFenceGateData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - powered: bool::from_snake_case(map.get("powered")?)?, - facing: BirchFenceGateFacing::from_snake_case(map.get("facing")?)?, in_wall: bool::from_snake_case(map.get("in_wall")?)?, open: bool::from_snake_case(map.get("open")?)?, + facing: BirchFenceGateFacing::from_snake_case(map.get("facing")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("powered".to_string(), self.powered.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("in_wall".to_string(), self.in_wall.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for BirchFenceGateData { + fn default() -> Self { + Self { + in_wall: false, + open: false, + facing: BirchFenceGateFacing::North, + powered: false, + } + } +} impl Value for BirchFenceGateData { fn value(&self) -> usize { - (self.powered.value() * 16usize) - + (self.facing.value() * 4usize) - + (self.in_wall.value() * 2usize) - + (self.open.value() * 1usize) + (self.in_wall.value() * 16usize) + + (self.open.value() * 8usize) + + (self.facing.value() * 2usize) + + (self.powered.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let powered = bool::from_value(val / 16usize).unwrap(); - val -= (powered.value() - 0usize) * 16usize; - let facing = BirchFenceGateFacing::from_value(val / 4usize).unwrap(); - val -= (facing.value() - 0usize) * 4usize; - let in_wall = bool::from_value(val / 2usize).unwrap(); - val -= (in_wall.value() - 0usize) * 2usize; - let open = bool::from_value(val / 1usize).unwrap(); - val -= (open.value() - 0usize) * 1usize; + let in_wall = bool::from_value(val / 16usize).unwrap(); + val -= (in_wall.value() - 0usize) * 16usize; + let open = bool::from_value(val / 8usize).unwrap(); + val -= (open.value() - 0usize) * 8usize; + let facing = BirchFenceGateFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let powered = bool::from_value(val / 1usize).unwrap(); + val -= (powered.value() - 0usize) * 1usize; Some(Self { - powered, - facing, in_wall, open, + facing, + powered, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct JungleFenceGateData { pub facing: JungleFenceGateFacing, - pub in_wall: bool, pub open: bool, pub powered: bool, + pub in_wall: bool, } impl JungleFenceGateData { pub fn from_map(map: &HashMap) -> Option { Some(Self { facing: JungleFenceGateFacing::from_snake_case(map.get("facing")?)?, - in_wall: bool::from_snake_case(map.get("in_wall")?)?, open: bool::from_snake_case(map.get("open")?)?, powered: bool::from_snake_case(map.get("powered")?)?, + in_wall: bool::from_snake_case(map.get("in_wall")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("in_wall".to_string(), self.in_wall.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); + m.insert("in_wall".to_string(), self.in_wall.to_snake_case()); m } } +impl Default for JungleFenceGateData { + fn default() -> Self { + Self { + facing: JungleFenceGateFacing::North, + open: false, + powered: false, + in_wall: false, + } + } +} impl Value for JungleFenceGateData { fn value(&self) -> usize { (self.facing.value() * 8usize) - + (self.in_wall.value() * 4usize) - + (self.open.value() * 2usize) - + (self.powered.value() * 1usize) + + (self.open.value() * 4usize) + + (self.powered.value() * 2usize) + + (self.in_wall.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -15767,103 +19437,123 @@ impl Value for JungleFenceGateData { } let facing = JungleFenceGateFacing::from_value(val / 8usize).unwrap(); val -= (facing.value() - 0usize) * 8usize; - let in_wall = bool::from_value(val / 4usize).unwrap(); - val -= (in_wall.value() - 0usize) * 4usize; - let open = bool::from_value(val / 2usize).unwrap(); - val -= (open.value() - 0usize) * 2usize; - let powered = bool::from_value(val / 1usize).unwrap(); - val -= (powered.value() - 0usize) * 1usize; + let open = bool::from_value(val / 4usize).unwrap(); + val -= (open.value() - 0usize) * 4usize; + let powered = bool::from_value(val / 2usize).unwrap(); + val -= (powered.value() - 0usize) * 2usize; + let in_wall = bool::from_value(val / 1usize).unwrap(); + val -= (in_wall.value() - 0usize) * 1usize; Some(Self { facing, - in_wall, open, powered, + in_wall, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct AcaciaFenceGateData { - pub facing: AcaciaFenceGateFacing, pub open: bool, pub powered: bool, pub in_wall: bool, + pub facing: AcaciaFenceGateFacing, } impl AcaciaFenceGateData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: AcaciaFenceGateFacing::from_snake_case(map.get("facing")?)?, open: bool::from_snake_case(map.get("open")?)?, powered: bool::from_snake_case(map.get("powered")?)?, in_wall: bool::from_snake_case(map.get("in_wall")?)?, + facing: AcaciaFenceGateFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("in_wall".to_string(), self.in_wall.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for AcaciaFenceGateData { + fn default() -> Self { + Self { + open: false, + powered: false, + in_wall: false, + facing: AcaciaFenceGateFacing::North, + } + } +} impl Value for AcaciaFenceGateData { fn value(&self) -> usize { - (self.facing.value() * 8usize) - + (self.open.value() * 4usize) - + (self.powered.value() * 2usize) - + (self.in_wall.value() * 1usize) + (self.open.value() * 16usize) + + (self.powered.value() * 8usize) + + (self.in_wall.value() * 4usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let facing = AcaciaFenceGateFacing::from_value(val / 8usize).unwrap(); - val -= (facing.value() - 0usize) * 8usize; - let open = bool::from_value(val / 4usize).unwrap(); - val -= (open.value() - 0usize) * 4usize; - let powered = bool::from_value(val / 2usize).unwrap(); - val -= (powered.value() - 0usize) * 2usize; - let in_wall = bool::from_value(val / 1usize).unwrap(); - val -= (in_wall.value() - 0usize) * 1usize; + let open = bool::from_value(val / 16usize).unwrap(); + val -= (open.value() - 0usize) * 16usize; + let powered = bool::from_value(val / 8usize).unwrap(); + val -= (powered.value() - 0usize) * 8usize; + let in_wall = bool::from_value(val / 4usize).unwrap(); + val -= (in_wall.value() - 0usize) * 4usize; + let facing = AcaciaFenceGateFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { - facing, open, powered, in_wall, + facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DarkOakFenceGateData { - pub powered: bool, pub facing: DarkOakFenceGateFacing, pub in_wall: bool, + pub powered: bool, pub open: bool, } impl DarkOakFenceGateData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - powered: bool::from_snake_case(map.get("powered")?)?, facing: DarkOakFenceGateFacing::from_snake_case(map.get("facing")?)?, in_wall: bool::from_snake_case(map.get("in_wall")?)?, + powered: bool::from_snake_case(map.get("powered")?)?, open: bool::from_snake_case(map.get("open")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("in_wall".to_string(), self.in_wall.to_snake_case()); + m.insert("powered".to_string(), self.powered.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); m } } +impl Default for DarkOakFenceGateData { + fn default() -> Self { + Self { + facing: DarkOakFenceGateFacing::North, + in_wall: false, + powered: false, + open: false, + } + } +} impl Value for DarkOakFenceGateData { fn value(&self) -> usize { - (self.powered.value() * 16usize) - + (self.facing.value() * 4usize) - + (self.in_wall.value() * 2usize) + (self.facing.value() * 8usize) + + (self.in_wall.value() * 4usize) + + (self.powered.value() * 2usize) + (self.open.value() * 1usize) } #[allow(warnings)] @@ -15871,56 +19561,67 @@ impl Value for DarkOakFenceGateData { if val >= 32usize { return None; } - let powered = bool::from_value(val / 16usize).unwrap(); - val -= (powered.value() - 0usize) * 16usize; - let facing = DarkOakFenceGateFacing::from_value(val / 4usize).unwrap(); - val -= (facing.value() - 0usize) * 4usize; - let in_wall = bool::from_value(val / 2usize).unwrap(); - val -= (in_wall.value() - 0usize) * 2usize; + let facing = DarkOakFenceGateFacing::from_value(val / 8usize).unwrap(); + val -= (facing.value() - 0usize) * 8usize; + let in_wall = bool::from_value(val / 4usize).unwrap(); + val -= (in_wall.value() - 0usize) * 4usize; + let powered = bool::from_value(val / 2usize).unwrap(); + val -= (powered.value() - 0usize) * 2usize; let open = bool::from_value(val / 1usize).unwrap(); val -= (open.value() - 0usize) * 1usize; Some(Self { - powered, facing, in_wall, + powered, open, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct SpruceFenceData { - pub west: bool, pub waterlogged: bool, - pub east: bool, pub north: bool, + pub west: bool, + pub east: bool, pub south: bool, } impl SpruceFenceData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - west: bool::from_snake_case(map.get("west")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - east: bool::from_snake_case(map.get("east")?)?, north: bool::from_snake_case(map.get("north")?)?, + west: bool::from_snake_case(map.get("west")?)?, + east: bool::from_snake_case(map.get("east")?)?, south: bool::from_snake_case(map.get("south")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("west".to_string(), self.west.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); m } } +impl Default for SpruceFenceData { + fn default() -> Self { + Self { + waterlogged: false, + north: false, + west: false, + east: false, + south: false, + } + } +} impl Value for SpruceFenceData { fn value(&self) -> usize { - (self.west.value() * 16usize) - + (self.waterlogged.value() * 8usize) - + (self.east.value() * 4usize) - + (self.north.value() * 2usize) + (self.waterlogged.value() * 16usize) + + (self.north.value() * 8usize) + + (self.west.value() * 4usize) + + (self.east.value() * 2usize) + (self.south.value() * 1usize) } #[allow(warnings)] @@ -15928,120 +19629,142 @@ impl Value for SpruceFenceData { if val >= 32usize { return None; } - let west = bool::from_value(val / 16usize).unwrap(); - val -= (west.value() - 0usize) * 16usize; - let waterlogged = bool::from_value(val / 8usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 8usize; - let east = bool::from_value(val / 4usize).unwrap(); - val -= (east.value() - 0usize) * 4usize; - let north = bool::from_value(val / 2usize).unwrap(); - val -= (north.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 16usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 16usize; + let north = bool::from_value(val / 8usize).unwrap(); + val -= (north.value() - 0usize) * 8usize; + let west = bool::from_value(val / 4usize).unwrap(); + val -= (west.value() - 0usize) * 4usize; + let east = bool::from_value(val / 2usize).unwrap(); + val -= (east.value() - 0usize) * 2usize; let south = bool::from_value(val / 1usize).unwrap(); val -= (south.value() - 0usize) * 1usize; Some(Self { - west, waterlogged, - east, north, + west, + east, south, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BirchFenceData { - pub west: bool, - pub waterlogged: bool, - pub north: bool, pub south: bool, pub east: bool, + pub north: bool, + pub waterlogged: bool, + pub west: bool, } impl BirchFenceData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - west: bool::from_snake_case(map.get("west")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, - north: bool::from_snake_case(map.get("north")?)?, south: bool::from_snake_case(map.get("south")?)?, east: bool::from_snake_case(map.get("east")?)?, + north: bool::from_snake_case(map.get("north")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + west: bool::from_snake_case(map.get("west")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); - m.insert("north".to_string(), self.north.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); + m.insert("north".to_string(), self.north.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); m } } +impl Default for BirchFenceData { + fn default() -> Self { + Self { + south: false, + east: false, + north: false, + waterlogged: false, + west: false, + } + } +} impl Value for BirchFenceData { fn value(&self) -> usize { - (self.west.value() * 16usize) - + (self.waterlogged.value() * 8usize) + (self.south.value() * 16usize) + + (self.east.value() * 8usize) + (self.north.value() * 4usize) - + (self.south.value() * 2usize) - + (self.east.value() * 1usize) + + (self.waterlogged.value() * 2usize) + + (self.west.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 32usize { return None; } - let west = bool::from_value(val / 16usize).unwrap(); - val -= (west.value() - 0usize) * 16usize; - let waterlogged = bool::from_value(val / 8usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 8usize; + let south = bool::from_value(val / 16usize).unwrap(); + val -= (south.value() - 0usize) * 16usize; + let east = bool::from_value(val / 8usize).unwrap(); + val -= (east.value() - 0usize) * 8usize; let north = bool::from_value(val / 4usize).unwrap(); val -= (north.value() - 0usize) * 4usize; - let south = bool::from_value(val / 2usize).unwrap(); - val -= (south.value() - 0usize) * 2usize; - let east = bool::from_value(val / 1usize).unwrap(); - val -= (east.value() - 0usize) * 1usize; + let waterlogged = bool::from_value(val / 2usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 2usize; + let west = bool::from_value(val / 1usize).unwrap(); + val -= (west.value() - 0usize) * 1usize; Some(Self { - west, - waterlogged, - north, south, east, + north, + waterlogged, + west, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct JungleFenceData { pub south: bool, - pub west: bool, - pub east: bool, pub north: bool, pub waterlogged: bool, + pub west: bool, + pub east: bool, } impl JungleFenceData { pub fn from_map(map: &HashMap) -> Option { Some(Self { south: bool::from_snake_case(map.get("south")?)?, - west: bool::from_snake_case(map.get("west")?)?, - east: bool::from_snake_case(map.get("east")?)?, north: bool::from_snake_case(map.get("north")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + west: bool::from_snake_case(map.get("west")?)?, + east: bool::from_snake_case(map.get("east")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("west".to_string(), self.west.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m } } +impl Default for JungleFenceData { + fn default() -> Self { + Self { + south: false, + north: false, + waterlogged: false, + west: false, + east: false, + } + } +} impl Value for JungleFenceData { fn value(&self) -> usize { (self.south.value() * 16usize) - + (self.west.value() * 8usize) - + (self.east.value() * 4usize) - + (self.north.value() * 2usize) - + (self.waterlogged.value() * 1usize) + + (self.north.value() * 8usize) + + (self.waterlogged.value() * 4usize) + + (self.west.value() * 2usize) + + (self.east.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -16050,56 +19773,67 @@ impl Value for JungleFenceData { } let south = bool::from_value(val / 16usize).unwrap(); val -= (south.value() - 0usize) * 16usize; - let west = bool::from_value(val / 8usize).unwrap(); - val -= (west.value() - 0usize) * 8usize; - let east = bool::from_value(val / 4usize).unwrap(); - val -= (east.value() - 0usize) * 4usize; - let north = bool::from_value(val / 2usize).unwrap(); - val -= (north.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let north = bool::from_value(val / 8usize).unwrap(); + val -= (north.value() - 0usize) * 8usize; + let waterlogged = bool::from_value(val / 4usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 4usize; + let west = bool::from_value(val / 2usize).unwrap(); + val -= (west.value() - 0usize) * 2usize; + let east = bool::from_value(val / 1usize).unwrap(); + val -= (east.value() - 0usize) * 1usize; Some(Self { south, - west, - east, north, waterlogged, + west, + east, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct AcaciaFenceData { + pub north: bool, pub east: bool, pub south: bool, - pub north: bool, pub waterlogged: bool, pub west: bool, } impl AcaciaFenceData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + north: bool::from_snake_case(map.get("north")?)?, east: bool::from_snake_case(map.get("east")?)?, south: bool::from_snake_case(map.get("south")?)?, - north: bool::from_snake_case(map.get("north")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, west: bool::from_snake_case(map.get("west")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("north".to_string(), self.north.to_snake_case()); m.insert("east".to_string(), self.east.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); - m.insert("north".to_string(), self.north.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); m } } +impl Default for AcaciaFenceData { + fn default() -> Self { + Self { + north: false, + east: false, + south: false, + waterlogged: false, + west: false, + } + } +} impl Value for AcaciaFenceData { fn value(&self) -> usize { - (self.east.value() * 16usize) - + (self.south.value() * 8usize) - + (self.north.value() * 4usize) + (self.north.value() * 16usize) + + (self.east.value() * 8usize) + + (self.south.value() * 4usize) + (self.waterlogged.value() * 2usize) + (self.west.value() * 1usize) } @@ -16108,20 +19842,20 @@ impl Value for AcaciaFenceData { if val >= 32usize { return None; } - let east = bool::from_value(val / 16usize).unwrap(); - val -= (east.value() - 0usize) * 16usize; - let south = bool::from_value(val / 8usize).unwrap(); - val -= (south.value() - 0usize) * 8usize; - let north = bool::from_value(val / 4usize).unwrap(); - val -= (north.value() - 0usize) * 4usize; + let north = bool::from_value(val / 16usize).unwrap(); + val -= (north.value() - 0usize) * 16usize; + let east = bool::from_value(val / 8usize).unwrap(); + val -= (east.value() - 0usize) * 8usize; + let south = bool::from_value(val / 4usize).unwrap(); + val -= (south.value() - 0usize) * 4usize; let waterlogged = bool::from_value(val / 2usize).unwrap(); val -= (waterlogged.value() - 0usize) * 2usize; let west = bool::from_value(val / 1usize).unwrap(); val -= (west.value() - 0usize) * 1usize; Some(Self { + north, east, south, - north, waterlogged, west, }) @@ -16129,37 +19863,48 @@ impl Value for AcaciaFenceData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DarkOakFenceData { - pub east: bool, - pub waterlogged: bool, pub north: bool, + pub waterlogged: bool, + pub east: bool, pub south: bool, pub west: bool, } impl DarkOakFenceData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - east: bool::from_snake_case(map.get("east")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, north: bool::from_snake_case(map.get("north")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + east: bool::from_snake_case(map.get("east")?)?, south: bool::from_snake_case(map.get("south")?)?, west: bool::from_snake_case(map.get("west")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("east".to_string(), self.east.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("north".to_string(), self.north.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); m } } +impl Default for DarkOakFenceData { + fn default() -> Self { + Self { + north: false, + waterlogged: false, + east: false, + south: false, + west: false, + } + } +} impl Value for DarkOakFenceData { fn value(&self) -> usize { - (self.east.value() * 16usize) + (self.north.value() * 16usize) + (self.waterlogged.value() * 8usize) - + (self.north.value() * 4usize) + + (self.east.value() * 4usize) + (self.south.value() * 2usize) + (self.west.value() * 1usize) } @@ -16168,20 +19913,20 @@ impl Value for DarkOakFenceData { if val >= 32usize { return None; } - let east = bool::from_value(val / 16usize).unwrap(); - val -= (east.value() - 0usize) * 16usize; + let north = bool::from_value(val / 16usize).unwrap(); + val -= (north.value() - 0usize) * 16usize; let waterlogged = bool::from_value(val / 8usize).unwrap(); val -= (waterlogged.value() - 0usize) * 8usize; - let north = bool::from_value(val / 4usize).unwrap(); - val -= (north.value() - 0usize) * 4usize; + let east = bool::from_value(val / 4usize).unwrap(); + val -= (east.value() - 0usize) * 4usize; let south = bool::from_value(val / 2usize).unwrap(); val -= (south.value() - 0usize) * 2usize; let west = bool::from_value(val / 1usize).unwrap(); val -= (west.value() - 0usize) * 1usize; Some(Self { - east, - waterlogged, north, + waterlogged, + east, south, west, }) @@ -16189,159 +19934,192 @@ impl Value for DarkOakFenceData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct SpruceDoorData { - pub half: SpruceDoorHalf, - pub open: bool, pub powered: bool, - pub facing: SpruceDoorFacing, pub hinge: SpruceDoorHinge, + pub facing: SpruceDoorFacing, + pub half: SpruceDoorHalf, + pub open: bool, } impl SpruceDoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - half: SpruceDoorHalf::from_snake_case(map.get("half")?)?, - open: bool::from_snake_case(map.get("open")?)?, powered: bool::from_snake_case(map.get("powered")?)?, - facing: SpruceDoorFacing::from_snake_case(map.get("facing")?)?, hinge: SpruceDoorHinge::from_snake_case(map.get("hinge")?)?, + facing: SpruceDoorFacing::from_snake_case(map.get("facing")?)?, + half: SpruceDoorHalf::from_snake_case(map.get("half")?)?, + open: bool::from_snake_case(map.get("open")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("half".to_string(), self.half.to_snake_case()); - m.insert("open".to_string(), self.open.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("hinge".to_string(), self.hinge.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("open".to_string(), self.open.to_snake_case()); m } } +impl Default for SpruceDoorData { + fn default() -> Self { + Self { + powered: false, + hinge: SpruceDoorHinge::Left, + facing: SpruceDoorFacing::North, + half: SpruceDoorHalf::Lower, + open: false, + } + } +} impl Value for SpruceDoorData { fn value(&self) -> usize { - (self.half.value() * 32usize) - + (self.open.value() * 16usize) - + (self.powered.value() * 8usize) - + (self.facing.value() * 2usize) - + (self.hinge.value() * 1usize) + (self.powered.value() * 32usize) + + (self.hinge.value() * 16usize) + + (self.facing.value() * 4usize) + + (self.half.value() * 2usize) + + (self.open.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 64usize { return None; } - let half = SpruceDoorHalf::from_value(val / 32usize).unwrap(); - val -= (half.value() - 0usize) * 32usize; - let open = bool::from_value(val / 16usize).unwrap(); - val -= (open.value() - 0usize) * 16usize; - let powered = bool::from_value(val / 8usize).unwrap(); - val -= (powered.value() - 0usize) * 8usize; - let facing = SpruceDoorFacing::from_value(val / 2usize).unwrap(); - val -= (facing.value() - 0usize) * 2usize; - let hinge = SpruceDoorHinge::from_value(val / 1usize).unwrap(); - val -= (hinge.value() - 0usize) * 1usize; + let powered = bool::from_value(val / 32usize).unwrap(); + val -= (powered.value() - 0usize) * 32usize; + let hinge = SpruceDoorHinge::from_value(val / 16usize).unwrap(); + val -= (hinge.value() - 0usize) * 16usize; + let facing = SpruceDoorFacing::from_value(val / 4usize).unwrap(); + val -= (facing.value() - 0usize) * 4usize; + let half = SpruceDoorHalf::from_value(val / 2usize).unwrap(); + val -= (half.value() - 0usize) * 2usize; + let open = bool::from_value(val / 1usize).unwrap(); + val -= (open.value() - 0usize) * 1usize; Some(Self { - half, - open, powered, - facing, hinge, + facing, + half, + open, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct BirchDoorData { - pub facing: BirchDoorFacing, + pub half: BirchDoorHalf, pub open: bool, - pub hinge: BirchDoorHinge, pub powered: bool, - pub half: BirchDoorHalf, + pub hinge: BirchDoorHinge, + pub facing: BirchDoorFacing, } impl BirchDoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: BirchDoorFacing::from_snake_case(map.get("facing")?)?, + half: BirchDoorHalf::from_snake_case(map.get("half")?)?, open: bool::from_snake_case(map.get("open")?)?, - hinge: BirchDoorHinge::from_snake_case(map.get("hinge")?)?, powered: bool::from_snake_case(map.get("powered")?)?, - half: BirchDoorHalf::from_snake_case(map.get("half")?)?, + hinge: BirchDoorHinge::from_snake_case(map.get("hinge")?)?, + facing: BirchDoorFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); - m.insert("hinge".to_string(), self.hinge.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); + m.insert("hinge".to_string(), self.hinge.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for BirchDoorData { + fn default() -> Self { + Self { + half: BirchDoorHalf::Lower, + open: false, + powered: false, + hinge: BirchDoorHinge::Left, + facing: BirchDoorFacing::North, + } + } +} impl Value for BirchDoorData { fn value(&self) -> usize { - (self.facing.value() * 16usize) - + (self.open.value() * 8usize) + (self.half.value() * 32usize) + + (self.open.value() * 16usize) + + (self.powered.value() * 8usize) + (self.hinge.value() * 4usize) - + (self.powered.value() * 2usize) - + (self.half.value() * 1usize) + + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 64usize { return None; } - let facing = BirchDoorFacing::from_value(val / 16usize).unwrap(); - val -= (facing.value() - 0usize) * 16usize; - let open = bool::from_value(val / 8usize).unwrap(); - val -= (open.value() - 0usize) * 8usize; + let half = BirchDoorHalf::from_value(val / 32usize).unwrap(); + val -= (half.value() - 0usize) * 32usize; + let open = bool::from_value(val / 16usize).unwrap(); + val -= (open.value() - 0usize) * 16usize; + let powered = bool::from_value(val / 8usize).unwrap(); + val -= (powered.value() - 0usize) * 8usize; let hinge = BirchDoorHinge::from_value(val / 4usize).unwrap(); val -= (hinge.value() - 0usize) * 4usize; - let powered = bool::from_value(val / 2usize).unwrap(); - val -= (powered.value() - 0usize) * 2usize; - let half = BirchDoorHalf::from_value(val / 1usize).unwrap(); - val -= (half.value() - 0usize) * 1usize; + let facing = BirchDoorFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { - facing, + half, open, - hinge, powered, - half, + hinge, + facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct JungleDoorData { pub facing: JungleDoorFacing, - pub half: JungleDoorHalf, - pub open: bool, pub powered: bool, + pub open: bool, pub hinge: JungleDoorHinge, + pub half: JungleDoorHalf, } impl JungleDoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { facing: JungleDoorFacing::from_snake_case(map.get("facing")?)?, - half: JungleDoorHalf::from_snake_case(map.get("half")?)?, - open: bool::from_snake_case(map.get("open")?)?, powered: bool::from_snake_case(map.get("powered")?)?, + open: bool::from_snake_case(map.get("open")?)?, hinge: JungleDoorHinge::from_snake_case(map.get("hinge")?)?, + half: JungleDoorHalf::from_snake_case(map.get("half")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); - m.insert("open".to_string(), self.open.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); + m.insert("open".to_string(), self.open.to_snake_case()); m.insert("hinge".to_string(), self.hinge.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); m } } +impl Default for JungleDoorData { + fn default() -> Self { + Self { + facing: JungleDoorFacing::North, + powered: false, + open: false, + hinge: JungleDoorHinge::Left, + half: JungleDoorHalf::Lower, + } + } +} impl Value for JungleDoorData { fn value(&self) -> usize { (self.facing.value() * 16usize) - + (self.half.value() * 8usize) + + (self.powered.value() * 8usize) + (self.open.value() * 4usize) - + (self.powered.value() * 2usize) - + (self.hinge.value() * 1usize) + + (self.hinge.value() * 2usize) + + (self.half.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -16350,27 +20128,27 @@ impl Value for JungleDoorData { } let facing = JungleDoorFacing::from_value(val / 16usize).unwrap(); val -= (facing.value() - 0usize) * 16usize; - let half = JungleDoorHalf::from_value(val / 8usize).unwrap(); - val -= (half.value() - 0usize) * 8usize; + let powered = bool::from_value(val / 8usize).unwrap(); + val -= (powered.value() - 0usize) * 8usize; let open = bool::from_value(val / 4usize).unwrap(); val -= (open.value() - 0usize) * 4usize; - let powered = bool::from_value(val / 2usize).unwrap(); - val -= (powered.value() - 0usize) * 2usize; - let hinge = JungleDoorHinge::from_value(val / 1usize).unwrap(); - val -= (hinge.value() - 0usize) * 1usize; + let hinge = JungleDoorHinge::from_value(val / 2usize).unwrap(); + val -= (hinge.value() - 0usize) * 2usize; + let half = JungleDoorHalf::from_value(val / 1usize).unwrap(); + val -= (half.value() - 0usize) * 1usize; Some(Self { facing, - half, - open, powered, + open, hinge, + half, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct AcaciaDoorData { - pub half: AcaciaDoorHalf, pub facing: AcaciaDoorFacing, + pub half: AcaciaDoorHalf, pub hinge: AcaciaDoorHinge, pub open: bool, pub powered: bool, @@ -16378,8 +20156,8 @@ pub struct AcaciaDoorData { impl AcaciaDoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - half: AcaciaDoorHalf::from_snake_case(map.get("half")?)?, facing: AcaciaDoorFacing::from_snake_case(map.get("facing")?)?, + half: AcaciaDoorHalf::from_snake_case(map.get("half")?)?, hinge: AcaciaDoorHinge::from_snake_case(map.get("hinge")?)?, open: bool::from_snake_case(map.get("open")?)?, powered: bool::from_snake_case(map.get("powered")?)?, @@ -16387,18 +20165,29 @@ impl AcaciaDoorData { } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("half".to_string(), self.half.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); m.insert("hinge".to_string(), self.hinge.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); m } } +impl Default for AcaciaDoorData { + fn default() -> Self { + Self { + facing: AcaciaDoorFacing::North, + half: AcaciaDoorHalf::Lower, + hinge: AcaciaDoorHinge::Left, + open: false, + powered: false, + } + } +} impl Value for AcaciaDoorData { fn value(&self) -> usize { - (self.half.value() * 32usize) - + (self.facing.value() * 8usize) + (self.facing.value() * 16usize) + + (self.half.value() * 8usize) + (self.hinge.value() * 4usize) + (self.open.value() * 2usize) + (self.powered.value() * 1usize) @@ -16408,10 +20197,10 @@ impl Value for AcaciaDoorData { if val >= 64usize { return None; } - let half = AcaciaDoorHalf::from_value(val / 32usize).unwrap(); - val -= (half.value() - 0usize) * 32usize; - let facing = AcaciaDoorFacing::from_value(val / 8usize).unwrap(); - val -= (facing.value() - 0usize) * 8usize; + let facing = AcaciaDoorFacing::from_value(val / 16usize).unwrap(); + val -= (facing.value() - 0usize) * 16usize; + let half = AcaciaDoorHalf::from_value(val / 8usize).unwrap(); + val -= (half.value() - 0usize) * 8usize; let hinge = AcaciaDoorHinge::from_value(val / 4usize).unwrap(); val -= (hinge.value() - 0usize) * 4usize; let open = bool::from_value(val / 2usize).unwrap(); @@ -16419,8 +20208,8 @@ impl Value for AcaciaDoorData { let powered = bool::from_value(val / 1usize).unwrap(); val -= (powered.value() - 0usize) * 1usize; Some(Self { - half, facing, + half, hinge, open, powered, @@ -16430,38 +20219,49 @@ impl Value for AcaciaDoorData { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DarkOakDoorData { pub facing: DarkOakDoorFacing, - pub half: DarkOakDoorHalf, pub powered: bool, - pub hinge: DarkOakDoorHinge, + pub half: DarkOakDoorHalf, pub open: bool, + pub hinge: DarkOakDoorHinge, } impl DarkOakDoorData { pub fn from_map(map: &HashMap) -> Option { Some(Self { facing: DarkOakDoorFacing::from_snake_case(map.get("facing")?)?, - half: DarkOakDoorHalf::from_snake_case(map.get("half")?)?, powered: bool::from_snake_case(map.get("powered")?)?, - hinge: DarkOakDoorHinge::from_snake_case(map.get("hinge")?)?, + half: DarkOakDoorHalf::from_snake_case(map.get("half")?)?, open: bool::from_snake_case(map.get("open")?)?, + hinge: DarkOakDoorHinge::from_snake_case(map.get("hinge")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("half".to_string(), self.half.to_snake_case()); m.insert("powered".to_string(), self.powered.to_snake_case()); - m.insert("hinge".to_string(), self.hinge.to_snake_case()); + m.insert("half".to_string(), self.half.to_snake_case()); m.insert("open".to_string(), self.open.to_snake_case()); + m.insert("hinge".to_string(), self.hinge.to_snake_case()); m } } +impl Default for DarkOakDoorData { + fn default() -> Self { + Self { + facing: DarkOakDoorFacing::North, + powered: false, + half: DarkOakDoorHalf::Lower, + open: false, + hinge: DarkOakDoorHinge::Left, + } + } +} impl Value for DarkOakDoorData { fn value(&self) -> usize { (self.facing.value() * 16usize) - + (self.half.value() * 8usize) - + (self.powered.value() * 4usize) - + (self.hinge.value() * 2usize) - + (self.open.value() * 1usize) + + (self.powered.value() * 8usize) + + (self.half.value() * 4usize) + + (self.open.value() * 2usize) + + (self.hinge.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { @@ -16470,20 +20270,20 @@ impl Value for DarkOakDoorData { } let facing = DarkOakDoorFacing::from_value(val / 16usize).unwrap(); val -= (facing.value() - 0usize) * 16usize; - let half = DarkOakDoorHalf::from_value(val / 8usize).unwrap(); - val -= (half.value() - 0usize) * 8usize; - let powered = bool::from_value(val / 4usize).unwrap(); - val -= (powered.value() - 0usize) * 4usize; - let hinge = DarkOakDoorHinge::from_value(val / 2usize).unwrap(); - val -= (hinge.value() - 0usize) * 2usize; - let open = bool::from_value(val / 1usize).unwrap(); - val -= (open.value() - 0usize) * 1usize; + let powered = bool::from_value(val / 8usize).unwrap(); + val -= (powered.value() - 0usize) * 8usize; + let half = DarkOakDoorHalf::from_value(val / 4usize).unwrap(); + val -= (half.value() - 0usize) * 4usize; + let open = bool::from_value(val / 2usize).unwrap(); + val -= (open.value() - 0usize) * 2usize; + let hinge = DarkOakDoorHinge::from_value(val / 1usize).unwrap(); + val -= (hinge.value() - 0usize) * 1usize; Some(Self { facing, - half, powered, - hinge, + half, open, + hinge, }) } } @@ -16503,6 +20303,13 @@ impl EndRodData { m } } +impl Default for EndRodData { + fn default() -> Self { + Self { + facing: EndRodFacing::Up, + } + } +} impl Value for EndRodData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -16519,68 +20326,80 @@ impl Value for EndRodData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct ChorusPlantData { + pub north: bool, pub down: bool, - pub east: bool, pub south: bool, + pub east: bool, pub up: bool, pub west: bool, - pub north: bool, } impl ChorusPlantData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + north: bool::from_snake_case(map.get("north")?)?, down: bool::from_snake_case(map.get("down")?)?, - east: bool::from_snake_case(map.get("east")?)?, south: bool::from_snake_case(map.get("south")?)?, + east: bool::from_snake_case(map.get("east")?)?, up: bool::from_snake_case(map.get("up")?)?, west: bool::from_snake_case(map.get("west")?)?, - north: bool::from_snake_case(map.get("north")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("north".to_string(), self.north.to_snake_case()); m.insert("down".to_string(), self.down.to_snake_case()); - m.insert("east".to_string(), self.east.to_snake_case()); m.insert("south".to_string(), self.south.to_snake_case()); + m.insert("east".to_string(), self.east.to_snake_case()); m.insert("up".to_string(), self.up.to_snake_case()); m.insert("west".to_string(), self.west.to_snake_case()); - m.insert("north".to_string(), self.north.to_snake_case()); m } } +impl Default for ChorusPlantData { + fn default() -> Self { + Self { + north: false, + down: false, + south: false, + east: false, + up: false, + west: false, + } + } +} impl Value for ChorusPlantData { fn value(&self) -> usize { - (self.down.value() * 32usize) - + (self.east.value() * 16usize) + (self.north.value() * 32usize) + + (self.down.value() * 16usize) + (self.south.value() * 8usize) - + (self.up.value() * 4usize) - + (self.west.value() * 2usize) - + (self.north.value() * 1usize) + + (self.east.value() * 4usize) + + (self.up.value() * 2usize) + + (self.west.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 64usize { return None; } - let down = bool::from_value(val / 32usize).unwrap(); - val -= (down.value() - 0usize) * 32usize; - let east = bool::from_value(val / 16usize).unwrap(); - val -= (east.value() - 0usize) * 16usize; + let north = bool::from_value(val / 32usize).unwrap(); + val -= (north.value() - 0usize) * 32usize; + let down = bool::from_value(val / 16usize).unwrap(); + val -= (down.value() - 0usize) * 16usize; let south = bool::from_value(val / 8usize).unwrap(); val -= (south.value() - 0usize) * 8usize; - let up = bool::from_value(val / 4usize).unwrap(); - val -= (up.value() - 0usize) * 4usize; - let west = bool::from_value(val / 2usize).unwrap(); - val -= (west.value() - 0usize) * 2usize; - let north = bool::from_value(val / 1usize).unwrap(); - val -= (north.value() - 0usize) * 1usize; + let east = bool::from_value(val / 4usize).unwrap(); + val -= (east.value() - 0usize) * 4usize; + let up = bool::from_value(val / 2usize).unwrap(); + val -= (up.value() - 0usize) * 2usize; + let west = bool::from_value(val / 1usize).unwrap(); + val -= (west.value() - 0usize) * 1usize; Some(Self { + north, down, - east, south, + east, up, west, - north, }) } } @@ -16600,6 +20419,11 @@ impl ChorusFlowerData { m } } +impl Default for ChorusFlowerData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for ChorusFlowerData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -16630,6 +20454,13 @@ impl PurpurPillarData { m } } +impl Default for PurpurPillarData { + fn default() -> Self { + Self { + axis: PurpurPillarAxis::Y, + } + } +} impl Value for PurpurPillarData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -16646,54 +20477,64 @@ impl Value for PurpurPillarData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct PurpurStairsData { + pub waterlogged: bool, pub half: PurpurStairsHalf, - pub shape: PurpurStairsShape, pub facing: PurpurStairsFacing, - pub waterlogged: bool, + pub shape: PurpurStairsShape, } impl PurpurStairsData { pub fn from_map(map: &HashMap) -> Option { Some(Self { + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, half: PurpurStairsHalf::from_snake_case(map.get("half")?)?, - shape: PurpurStairsShape::from_snake_case(map.get("shape")?)?, facing: PurpurStairsFacing::from_snake_case(map.get("facing")?)?, - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + shape: PurpurStairsShape::from_snake_case(map.get("shape")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("half".to_string(), self.half.to_snake_case()); - m.insert("shape".to_string(), self.shape.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("shape".to_string(), self.shape.to_snake_case()); m } } +impl Default for PurpurStairsData { + fn default() -> Self { + Self { + waterlogged: false, + half: PurpurStairsHalf::Bottom, + facing: PurpurStairsFacing::North, + shape: PurpurStairsShape::Straight, + } + } +} impl Value for PurpurStairsData { fn value(&self) -> usize { - (self.half.value() * 40usize) - + (self.shape.value() * 8usize) - + (self.facing.value() * 2usize) - + (self.waterlogged.value() * 1usize) + (self.waterlogged.value() * 40usize) + + (self.half.value() * 20usize) + + (self.facing.value() * 5usize) + + (self.shape.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 80usize { return None; } - let half = PurpurStairsHalf::from_value(val / 40usize).unwrap(); - val -= (half.value() - 0usize) * 40usize; - let shape = PurpurStairsShape::from_value(val / 8usize).unwrap(); - val -= (shape.value() - 0usize) * 8usize; - let facing = PurpurStairsFacing::from_value(val / 2usize).unwrap(); - val -= (facing.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let waterlogged = bool::from_value(val / 40usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 40usize; + let half = PurpurStairsHalf::from_value(val / 20usize).unwrap(); + val -= (half.value() - 0usize) * 20usize; + let facing = PurpurStairsFacing::from_value(val / 5usize).unwrap(); + val -= (facing.value() - 0usize) * 5usize; + let shape = PurpurStairsShape::from_value(val / 1usize).unwrap(); + val -= (shape.value() - 0usize) * 1usize; Some(Self { + waterlogged, half, - shape, facing, - waterlogged, + shape, }) } } @@ -16713,6 +20554,11 @@ impl BeetrootsData { m } } +impl Default for BeetrootsData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for BeetrootsData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -16746,6 +20592,14 @@ impl RepeatingCommandBlockData { m } } +impl Default for RepeatingCommandBlockData { + fn default() -> Self { + Self { + facing: RepeatingCommandBlockFacing::North, + conditional: false, + } + } +} impl Value for RepeatingCommandBlockData { fn value(&self) -> usize { (self.facing.value() * 2usize) + (self.conditional.value() * 1usize) @@ -16784,6 +20638,14 @@ impl ChainCommandBlockData { m } } +impl Default for ChainCommandBlockData { + fn default() -> Self { + Self { + facing: ChainCommandBlockFacing::North, + conditional: false, + } + } +} impl Value for ChainCommandBlockData { fn value(&self) -> usize { (self.facing.value() * 2usize) + (self.conditional.value() * 1usize) @@ -16819,6 +20681,11 @@ impl FrostedIceData { m } } +impl Default for FrostedIceData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for FrostedIceData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -16849,6 +20716,13 @@ impl BoneBlockData { m } } +impl Default for BoneBlockData { + fn default() -> Self { + Self { + axis: BoneBlockAxis::Y, + } + } +} impl Value for BoneBlockData { fn value(&self) -> usize { (self.axis.value() * 1usize) @@ -16882,6 +20756,14 @@ impl ObserverData { m } } +impl Default for ObserverData { + fn default() -> Self { + Self { + facing: ObserverFacing::South, + powered: false, + } + } +} impl Value for ObserverData { fn value(&self) -> usize { (self.facing.value() * 2usize) + (self.powered.value() * 1usize) @@ -16914,6 +20796,13 @@ impl ShulkerBoxData { m } } +impl Default for ShulkerBoxData { + fn default() -> Self { + Self { + facing: ShulkerBoxFacing::Up, + } + } +} impl Value for ShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -16944,6 +20833,13 @@ impl WhiteShulkerBoxData { m } } +impl Default for WhiteShulkerBoxData { + fn default() -> Self { + Self { + facing: WhiteShulkerBoxFacing::Up, + } + } +} impl Value for WhiteShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -16974,6 +20870,13 @@ impl OrangeShulkerBoxData { m } } +impl Default for OrangeShulkerBoxData { + fn default() -> Self { + Self { + facing: OrangeShulkerBoxFacing::Up, + } + } +} impl Value for OrangeShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17004,6 +20907,13 @@ impl MagentaShulkerBoxData { m } } +impl Default for MagentaShulkerBoxData { + fn default() -> Self { + Self { + facing: MagentaShulkerBoxFacing::Up, + } + } +} impl Value for MagentaShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17034,6 +20944,13 @@ impl LightBlueShulkerBoxData { m } } +impl Default for LightBlueShulkerBoxData { + fn default() -> Self { + Self { + facing: LightBlueShulkerBoxFacing::Up, + } + } +} impl Value for LightBlueShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17064,6 +20981,13 @@ impl YellowShulkerBoxData { m } } +impl Default for YellowShulkerBoxData { + fn default() -> Self { + Self { + facing: YellowShulkerBoxFacing::Up, + } + } +} impl Value for YellowShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17094,6 +21018,13 @@ impl LimeShulkerBoxData { m } } +impl Default for LimeShulkerBoxData { + fn default() -> Self { + Self { + facing: LimeShulkerBoxFacing::Up, + } + } +} impl Value for LimeShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17124,6 +21055,13 @@ impl PinkShulkerBoxData { m } } +impl Default for PinkShulkerBoxData { + fn default() -> Self { + Self { + facing: PinkShulkerBoxFacing::Up, + } + } +} impl Value for PinkShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17154,6 +21092,13 @@ impl GrayShulkerBoxData { m } } +impl Default for GrayShulkerBoxData { + fn default() -> Self { + Self { + facing: GrayShulkerBoxFacing::Up, + } + } +} impl Value for GrayShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17184,6 +21129,13 @@ impl LightGrayShulkerBoxData { m } } +impl Default for LightGrayShulkerBoxData { + fn default() -> Self { + Self { + facing: LightGrayShulkerBoxFacing::Up, + } + } +} impl Value for LightGrayShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17214,6 +21166,13 @@ impl CyanShulkerBoxData { m } } +impl Default for CyanShulkerBoxData { + fn default() -> Self { + Self { + facing: CyanShulkerBoxFacing::Up, + } + } +} impl Value for CyanShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17244,6 +21203,13 @@ impl PurpleShulkerBoxData { m } } +impl Default for PurpleShulkerBoxData { + fn default() -> Self { + Self { + facing: PurpleShulkerBoxFacing::Up, + } + } +} impl Value for PurpleShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17274,6 +21240,13 @@ impl BlueShulkerBoxData { m } } +impl Default for BlueShulkerBoxData { + fn default() -> Self { + Self { + facing: BlueShulkerBoxFacing::Up, + } + } +} impl Value for BlueShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17304,6 +21277,13 @@ impl BrownShulkerBoxData { m } } +impl Default for BrownShulkerBoxData { + fn default() -> Self { + Self { + facing: BrownShulkerBoxFacing::Up, + } + } +} impl Value for BrownShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17334,6 +21314,13 @@ impl GreenShulkerBoxData { m } } +impl Default for GreenShulkerBoxData { + fn default() -> Self { + Self { + facing: GreenShulkerBoxFacing::Up, + } + } +} impl Value for GreenShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17364,6 +21351,13 @@ impl RedShulkerBoxData { m } } +impl Default for RedShulkerBoxData { + fn default() -> Self { + Self { + facing: RedShulkerBoxFacing::Up, + } + } +} impl Value for RedShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17394,6 +21388,13 @@ impl BlackShulkerBoxData { m } } +impl Default for BlackShulkerBoxData { + fn default() -> Self { + Self { + facing: BlackShulkerBoxFacing::Up, + } + } +} impl Value for BlackShulkerBoxData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17424,6 +21425,13 @@ impl WhiteGlazedTerracottaData { m } } +impl Default for WhiteGlazedTerracottaData { + fn default() -> Self { + Self { + facing: WhiteGlazedTerracottaFacing::North, + } + } +} impl Value for WhiteGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17454,6 +21462,13 @@ impl OrangeGlazedTerracottaData { m } } +impl Default for OrangeGlazedTerracottaData { + fn default() -> Self { + Self { + facing: OrangeGlazedTerracottaFacing::North, + } + } +} impl Value for OrangeGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17484,6 +21499,13 @@ impl MagentaGlazedTerracottaData { m } } +impl Default for MagentaGlazedTerracottaData { + fn default() -> Self { + Self { + facing: MagentaGlazedTerracottaFacing::North, + } + } +} impl Value for MagentaGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17514,6 +21536,13 @@ impl LightBlueGlazedTerracottaData { m } } +impl Default for LightBlueGlazedTerracottaData { + fn default() -> Self { + Self { + facing: LightBlueGlazedTerracottaFacing::North, + } + } +} impl Value for LightBlueGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17544,6 +21573,13 @@ impl YellowGlazedTerracottaData { m } } +impl Default for YellowGlazedTerracottaData { + fn default() -> Self { + Self { + facing: YellowGlazedTerracottaFacing::North, + } + } +} impl Value for YellowGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17574,6 +21610,13 @@ impl LimeGlazedTerracottaData { m } } +impl Default for LimeGlazedTerracottaData { + fn default() -> Self { + Self { + facing: LimeGlazedTerracottaFacing::North, + } + } +} impl Value for LimeGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17604,6 +21647,13 @@ impl PinkGlazedTerracottaData { m } } +impl Default for PinkGlazedTerracottaData { + fn default() -> Self { + Self { + facing: PinkGlazedTerracottaFacing::North, + } + } +} impl Value for PinkGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17634,6 +21684,13 @@ impl GrayGlazedTerracottaData { m } } +impl Default for GrayGlazedTerracottaData { + fn default() -> Self { + Self { + facing: GrayGlazedTerracottaFacing::North, + } + } +} impl Value for GrayGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17664,6 +21721,13 @@ impl LightGrayGlazedTerracottaData { m } } +impl Default for LightGrayGlazedTerracottaData { + fn default() -> Self { + Self { + facing: LightGrayGlazedTerracottaFacing::North, + } + } +} impl Value for LightGrayGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17694,6 +21758,13 @@ impl CyanGlazedTerracottaData { m } } +impl Default for CyanGlazedTerracottaData { + fn default() -> Self { + Self { + facing: CyanGlazedTerracottaFacing::North, + } + } +} impl Value for CyanGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17724,6 +21795,13 @@ impl PurpleGlazedTerracottaData { m } } +impl Default for PurpleGlazedTerracottaData { + fn default() -> Self { + Self { + facing: PurpleGlazedTerracottaFacing::North, + } + } +} impl Value for PurpleGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17754,6 +21832,13 @@ impl BlueGlazedTerracottaData { m } } +impl Default for BlueGlazedTerracottaData { + fn default() -> Self { + Self { + facing: BlueGlazedTerracottaFacing::North, + } + } +} impl Value for BlueGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17784,6 +21869,13 @@ impl BrownGlazedTerracottaData { m } } +impl Default for BrownGlazedTerracottaData { + fn default() -> Self { + Self { + facing: BrownGlazedTerracottaFacing::North, + } + } +} impl Value for BrownGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17814,6 +21906,13 @@ impl GreenGlazedTerracottaData { m } } +impl Default for GreenGlazedTerracottaData { + fn default() -> Self { + Self { + facing: GreenGlazedTerracottaFacing::North, + } + } +} impl Value for GreenGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17844,6 +21943,13 @@ impl RedGlazedTerracottaData { m } } +impl Default for RedGlazedTerracottaData { + fn default() -> Self { + Self { + facing: RedGlazedTerracottaFacing::North, + } + } +} impl Value for RedGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17874,6 +21980,13 @@ impl BlackGlazedTerracottaData { m } } +impl Default for BlackGlazedTerracottaData { + fn default() -> Self { + Self { + facing: BlackGlazedTerracottaFacing::North, + } + } +} impl Value for BlackGlazedTerracottaData { fn value(&self) -> usize { (self.facing.value() * 1usize) @@ -17904,6 +22017,11 @@ impl KelpData { m } } +impl Default for KelpData { + fn default() -> Self { + Self { age: 0 } + } +} impl Value for KelpData { fn value(&self) -> usize { (self.age.value() * 1usize) @@ -17937,6 +22055,11 @@ impl TurtleEggData { m } } +impl Default for TurtleEggData { + fn default() -> Self { + Self { eggs: 1, hatch: 0 } + } +} impl Value for TurtleEggData { fn value(&self) -> usize { ((self.eggs.value() - 1) * 3usize) + (self.hatch.value() * 1usize) @@ -17969,6 +22092,11 @@ impl DeadTubeCoralData { m } } +impl Default for DeadTubeCoralData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for DeadTubeCoralData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -17999,6 +22127,11 @@ impl DeadBrainCoralData { m } } +impl Default for DeadBrainCoralData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for DeadBrainCoralData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18029,6 +22162,11 @@ impl DeadBubbleCoralData { m } } +impl Default for DeadBubbleCoralData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for DeadBubbleCoralData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18059,6 +22197,11 @@ impl DeadFireCoralData { m } } +impl Default for DeadFireCoralData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for DeadFireCoralData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18089,6 +22232,11 @@ impl DeadHornCoralData { m } } +impl Default for DeadHornCoralData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for DeadHornCoralData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18119,6 +22267,11 @@ impl TubeCoralData { m } } +impl Default for TubeCoralData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for TubeCoralData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18149,6 +22302,11 @@ impl BrainCoralData { m } } +impl Default for BrainCoralData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for BrainCoralData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18179,6 +22337,11 @@ impl BubbleCoralData { m } } +impl Default for BubbleCoralData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for BubbleCoralData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18209,6 +22372,11 @@ impl FireCoralData { m } } +impl Default for FireCoralData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for FireCoralData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18239,6 +22407,11 @@ impl HornCoralData { m } } +impl Default for HornCoralData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for HornCoralData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18272,6 +22445,14 @@ impl DeadTubeCoralWallFanData { m } } +impl Default for DeadTubeCoralWallFanData { + fn default() -> Self { + Self { + facing: DeadTubeCoralWallFanFacing::North, + waterlogged: true, + } + } +} impl Value for DeadTubeCoralWallFanData { fn value(&self) -> usize { (self.facing.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -18293,39 +22474,47 @@ impl Value for DeadTubeCoralWallFanData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DeadBrainCoralWallFanData { - pub waterlogged: bool, pub facing: DeadBrainCoralWallFanFacing, + pub waterlogged: bool, } impl DeadBrainCoralWallFanData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, facing: DeadBrainCoralWallFanFacing::from_snake_case(map.get("facing")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for DeadBrainCoralWallFanData { + fn default() -> Self { + Self { + facing: DeadBrainCoralWallFanFacing::North, + waterlogged: true, + } + } +} impl Value for DeadBrainCoralWallFanData { fn value(&self) -> usize { - (self.waterlogged.value() * 4usize) + (self.facing.value() * 1usize) + (self.facing.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 8usize { return None; } - let waterlogged = bool::from_value(val / 4usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 4usize; - let facing = DeadBrainCoralWallFanFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let facing = DeadBrainCoralWallFanFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { - waterlogged, facing, + waterlogged, }) } } @@ -18348,6 +22537,14 @@ impl DeadBubbleCoralWallFanData { m } } +impl Default for DeadBubbleCoralWallFanData { + fn default() -> Self { + Self { + waterlogged: true, + facing: DeadBubbleCoralWallFanFacing::North, + } + } +} impl Value for DeadBubbleCoralWallFanData { fn value(&self) -> usize { (self.waterlogged.value() * 4usize) + (self.facing.value() * 1usize) @@ -18369,77 +22566,93 @@ impl Value for DeadBubbleCoralWallFanData { } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DeadFireCoralWallFanData { - pub facing: DeadFireCoralWallFanFacing, pub waterlogged: bool, + pub facing: DeadFireCoralWallFanFacing, } impl DeadFireCoralWallFanData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - facing: DeadFireCoralWallFanFacing::from_snake_case(map.get("facing")?)?, waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, + facing: DeadFireCoralWallFanFacing::from_snake_case(map.get("facing")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("facing".to_string(), self.facing.to_snake_case()); m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); + m.insert("facing".to_string(), self.facing.to_snake_case()); m } } +impl Default for DeadFireCoralWallFanData { + fn default() -> Self { + Self { + waterlogged: true, + facing: DeadFireCoralWallFanFacing::North, + } + } +} impl Value for DeadFireCoralWallFanData { fn value(&self) -> usize { - (self.facing.value() * 2usize) + (self.waterlogged.value() * 1usize) + (self.waterlogged.value() * 4usize) + (self.facing.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 8usize { return None; } - let facing = DeadFireCoralWallFanFacing::from_value(val / 2usize).unwrap(); - val -= (facing.value() - 0usize) * 2usize; - let waterlogged = bool::from_value(val / 1usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 1usize; + let waterlogged = bool::from_value(val / 4usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 4usize; + let facing = DeadFireCoralWallFanFacing::from_value(val / 1usize).unwrap(); + val -= (facing.value() - 0usize) * 1usize; Some(Self { - facing, waterlogged, + facing, }) } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub struct DeadHornCoralWallFanData { - pub waterlogged: bool, pub facing: DeadHornCoralWallFanFacing, + pub waterlogged: bool, } impl DeadHornCoralWallFanData { pub fn from_map(map: &HashMap) -> Option { Some(Self { - waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, facing: DeadHornCoralWallFanFacing::from_snake_case(map.get("facing")?)?, + waterlogged: bool::from_snake_case(map.get("waterlogged")?)?, }) } pub fn to_map(&self) -> HashMap { let mut m = HashMap::new(); - m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m.insert("facing".to_string(), self.facing.to_snake_case()); + m.insert("waterlogged".to_string(), self.waterlogged.to_snake_case()); m } } +impl Default for DeadHornCoralWallFanData { + fn default() -> Self { + Self { + facing: DeadHornCoralWallFanFacing::North, + waterlogged: true, + } + } +} impl Value for DeadHornCoralWallFanData { fn value(&self) -> usize { - (self.waterlogged.value() * 4usize) + (self.facing.value() * 1usize) + (self.facing.value() * 2usize) + (self.waterlogged.value() * 1usize) } #[allow(warnings)] fn from_value(mut val: usize) -> Option { if val >= 8usize { return None; } - let waterlogged = bool::from_value(val / 4usize).unwrap(); - val -= (waterlogged.value() - 0usize) * 4usize; - let facing = DeadHornCoralWallFanFacing::from_value(val / 1usize).unwrap(); - val -= (facing.value() - 0usize) * 1usize; + let facing = DeadHornCoralWallFanFacing::from_value(val / 2usize).unwrap(); + val -= (facing.value() - 0usize) * 2usize; + let waterlogged = bool::from_value(val / 1usize).unwrap(); + val -= (waterlogged.value() - 0usize) * 1usize; Some(Self { - waterlogged, facing, + waterlogged, }) } } @@ -18462,6 +22675,14 @@ impl TubeCoralWallFanData { m } } +impl Default for TubeCoralWallFanData { + fn default() -> Self { + Self { + facing: TubeCoralWallFanFacing::North, + waterlogged: true, + } + } +} impl Value for TubeCoralWallFanData { fn value(&self) -> usize { (self.facing.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -18500,6 +22721,14 @@ impl BrainCoralWallFanData { m } } +impl Default for BrainCoralWallFanData { + fn default() -> Self { + Self { + waterlogged: true, + facing: BrainCoralWallFanFacing::North, + } + } +} impl Value for BrainCoralWallFanData { fn value(&self) -> usize { (self.waterlogged.value() * 4usize) + (self.facing.value() * 1usize) @@ -18538,6 +22767,14 @@ impl BubbleCoralWallFanData { m } } +impl Default for BubbleCoralWallFanData { + fn default() -> Self { + Self { + facing: BubbleCoralWallFanFacing::North, + waterlogged: true, + } + } +} impl Value for BubbleCoralWallFanData { fn value(&self) -> usize { (self.facing.value() * 2usize) + (self.waterlogged.value() * 1usize) @@ -18576,6 +22813,14 @@ impl FireCoralWallFanData { m } } +impl Default for FireCoralWallFanData { + fn default() -> Self { + Self { + waterlogged: true, + facing: FireCoralWallFanFacing::North, + } + } +} impl Value for FireCoralWallFanData { fn value(&self) -> usize { (self.waterlogged.value() * 4usize) + (self.facing.value() * 1usize) @@ -18614,6 +22859,14 @@ impl HornCoralWallFanData { m } } +impl Default for HornCoralWallFanData { + fn default() -> Self { + Self { + waterlogged: true, + facing: HornCoralWallFanFacing::North, + } + } +} impl Value for HornCoralWallFanData { fn value(&self) -> usize { (self.waterlogged.value() * 4usize) + (self.facing.value() * 1usize) @@ -18649,6 +22902,11 @@ impl DeadTubeCoralFanData { m } } +impl Default for DeadTubeCoralFanData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for DeadTubeCoralFanData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18679,6 +22937,11 @@ impl DeadBrainCoralFanData { m } } +impl Default for DeadBrainCoralFanData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for DeadBrainCoralFanData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18709,6 +22972,11 @@ impl DeadBubbleCoralFanData { m } } +impl Default for DeadBubbleCoralFanData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for DeadBubbleCoralFanData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18739,6 +23007,11 @@ impl DeadFireCoralFanData { m } } +impl Default for DeadFireCoralFanData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for DeadFireCoralFanData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18769,6 +23042,11 @@ impl DeadHornCoralFanData { m } } +impl Default for DeadHornCoralFanData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for DeadHornCoralFanData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18799,6 +23077,11 @@ impl TubeCoralFanData { m } } +impl Default for TubeCoralFanData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for TubeCoralFanData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18829,6 +23112,11 @@ impl BrainCoralFanData { m } } +impl Default for BrainCoralFanData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for BrainCoralFanData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18859,6 +23147,11 @@ impl BubbleCoralFanData { m } } +impl Default for BubbleCoralFanData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for BubbleCoralFanData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18889,6 +23182,11 @@ impl FireCoralFanData { m } } +impl Default for FireCoralFanData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for FireCoralFanData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18919,6 +23217,11 @@ impl HornCoralFanData { m } } +impl Default for HornCoralFanData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for HornCoralFanData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -18952,6 +23255,14 @@ impl SeaPickleData { m } } +impl Default for SeaPickleData { + fn default() -> Self { + Self { + pickles: 1, + waterlogged: true, + } + } +} impl Value for SeaPickleData { fn value(&self) -> usize { ((self.pickles.value() - 1) * 2usize) + (self.waterlogged.value() * 1usize) @@ -18987,6 +23298,11 @@ impl ConduitData { m } } +impl Default for ConduitData { + fn default() -> Self { + Self { waterlogged: true } + } +} impl Value for ConduitData { fn value(&self) -> usize { (self.waterlogged.value() * 1usize) @@ -19017,6 +23333,11 @@ impl BubbleColumnData { m } } +impl Default for BubbleColumnData { + fn default() -> Self { + Self { drag: true } + } +} impl Value for BubbleColumnData { fn value(&self) -> usize { (self.drag.value() * 1usize) @@ -19047,6 +23368,13 @@ impl StructureBlockData { m } } +impl Default for StructureBlockData { + fn default() -> Self { + Self { + mode: StructureBlockMode::Save, + } + } +} impl Value for StructureBlockData { fn value(&self) -> usize { (self.mode.value() * 1usize) @@ -19492,19 +23820,6 @@ impl Value for OrangeBedPart { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum MagentaBedPart { - Head, - Foot, -} -impl Value for MagentaBedPart { - fn value(&self) -> usize { - *self as usize - } - fn from_value(val: usize) -> Option { - Self::from_usize(val) - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum MagentaBedFacing { North, South, @@ -19520,13 +23835,11 @@ impl Value for MagentaBedFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum LightBlueBedFacing { - North, - South, - West, - East, +pub enum MagentaBedPart { + Head, + Foot, } -impl Value for LightBlueBedFacing { +impl Value for MagentaBedPart { fn value(&self) -> usize { *self as usize } @@ -19548,13 +23861,13 @@ impl Value for LightBlueBedPart { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum YellowBedFacing { +pub enum LightBlueBedFacing { North, South, West, East, } -impl Value for YellowBedFacing { +impl Value for LightBlueBedFacing { fn value(&self) -> usize { *self as usize } @@ -19576,6 +23889,21 @@ impl Value for YellowBedPart { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] +pub enum YellowBedFacing { + North, + South, + West, + East, +} +impl Value for YellowBedFacing { + fn value(&self) -> usize { + *self as usize + } + fn from_value(val: usize) -> Option { + Self::from_usize(val) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum LimeBedPart { Head, Foot, @@ -19632,11 +23960,13 @@ impl Value for PinkBedFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum GrayBedPart { - Head, - Foot, +pub enum GrayBedFacing { + North, + South, + West, + East, } -impl Value for GrayBedPart { +impl Value for GrayBedFacing { fn value(&self) -> usize { *self as usize } @@ -19645,13 +23975,11 @@ impl Value for GrayBedPart { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum GrayBedFacing { - North, - South, - West, - East, +pub enum GrayBedPart { + Head, + Foot, } -impl Value for GrayBedFacing { +impl Value for GrayBedPart { fn value(&self) -> usize { *self as usize } @@ -19688,6 +24016,19 @@ impl Value for LightGrayBedPart { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] +pub enum CyanBedPart { + Head, + Foot, +} +impl Value for CyanBedPart { + fn value(&self) -> usize { + *self as usize + } + fn from_value(val: usize) -> Option { + Self::from_usize(val) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum CyanBedFacing { North, South, @@ -19703,11 +24044,11 @@ impl Value for CyanBedFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum CyanBedPart { +pub enum PurpleBedPart { Head, Foot, } -impl Value for CyanBedPart { +impl Value for PurpleBedPart { fn value(&self) -> usize { *self as usize } @@ -19731,19 +24072,6 @@ impl Value for PurpleBedFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum PurpleBedPart { - Head, - Foot, -} -impl Value for PurpleBedPart { - fn value(&self) -> usize { - *self as usize - } - fn from_value(val: usize) -> Option { - Self::from_usize(val) - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum BlueBedFacing { North, South, @@ -19995,11 +24323,15 @@ impl Value for PistonHeadFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum MovingPistonType { - Normal, - Sticky, +pub enum MovingPistonFacing { + North, + East, + South, + West, + Up, + Down, } -impl Value for MovingPistonType { +impl Value for MovingPistonFacing { fn value(&self) -> usize { *self as usize } @@ -20008,15 +24340,11 @@ impl Value for MovingPistonType { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum MovingPistonFacing { - North, - East, - South, - West, - Up, - Down, +pub enum MovingPistonType { + Normal, + Sticky, } -impl Value for MovingPistonFacing { +impl Value for MovingPistonType { fn value(&self) -> usize { *self as usize } @@ -20040,13 +24368,11 @@ impl Value for WallTorchFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum OakStairsFacing { - North, - South, - West, - East, +pub enum OakStairsHalf { + Top, + Bottom, } -impl Value for OakStairsFacing { +impl Value for OakStairsHalf { fn value(&self) -> usize { *self as usize } @@ -20071,11 +24397,27 @@ impl Value for OakStairsShape { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum OakStairsHalf { - Top, - Bottom, +pub enum OakStairsFacing { + North, + South, + West, + East, } -impl Value for OakStairsHalf { +impl Value for OakStairsFacing { + fn value(&self) -> usize { + *self as usize + } + fn from_value(val: usize) -> Option { + Self::from_usize(val) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] +pub enum ChestType { + Single, + Left, + Right, +} +impl Value for ChestType { fn value(&self) -> usize { *self as usize } @@ -20099,12 +24441,12 @@ impl Value for ChestFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum ChestType { - Single, - Left, - Right, +pub enum RedstoneWireWest { + Up, + Side, + None, } -impl Value for ChestType { +impl Value for RedstoneWireWest { fn value(&self) -> usize { *self as usize } @@ -20155,12 +24497,13 @@ impl Value for RedstoneWireSouth { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum RedstoneWireWest { - Up, - Side, - None, +pub enum FurnaceFacing { + North, + South, + West, + East, } -impl Value for RedstoneWireWest { +impl Value for FurnaceFacing { fn value(&self) -> usize { *self as usize } @@ -20169,13 +24512,11 @@ impl Value for RedstoneWireWest { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum FurnaceFacing { - North, - South, - West, - East, +pub enum OakDoorHalf { + Upper, + Lower, } -impl Value for FurnaceFacing { +impl Value for OakDoorHalf { fn value(&self) -> usize { *self as usize } @@ -20199,19 +24540,6 @@ impl Value for OakDoorFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum OakDoorHalf { - Upper, - Lower, -} -impl Value for OakDoorHalf { - fn value(&self) -> usize { - *self as usize - } - fn from_value(val: usize) -> Option { - Self::from_usize(val) - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum OakDoorHinge { Left, Right, @@ -20261,6 +24589,21 @@ impl Value for RailShape { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] +pub enum CobblestoneStairsFacing { + North, + South, + West, + East, +} +impl Value for CobblestoneStairsFacing { + fn value(&self) -> usize { + *self as usize + } + fn from_value(val: usize) -> Option { + Self::from_usize(val) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum CobblestoneStairsHalf { Top, Bottom, @@ -20290,21 +24633,6 @@ impl Value for CobblestoneStairsShape { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum CobblestoneStairsFacing { - North, - South, - West, - East, -} -impl Value for CobblestoneStairsFacing { - fn value(&self) -> usize { - *self as usize - } - fn from_value(val: usize) -> Option { - Self::from_usize(val) - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum WallSignFacing { North, South, @@ -20349,13 +24677,11 @@ impl Value for LeverFace { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum IronDoorFacing { - North, - South, - West, - East, +pub enum IronDoorHalf { + Upper, + Lower, } -impl Value for IronDoorFacing { +impl Value for IronDoorHalf { fn value(&self) -> usize { *self as usize } @@ -20364,11 +24690,13 @@ impl Value for IronDoorFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum IronDoorHalf { - Upper, - Lower, +pub enum IronDoorFacing { + North, + South, + West, + East, } -impl Value for IronDoorHalf { +impl Value for IronDoorFacing { fn value(&self) -> usize { *self as usize } @@ -20492,13 +24820,11 @@ impl Value for RepeaterFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum OakTrapdoorFacing { - North, - South, - West, - East, +pub enum OakTrapdoorHalf { + Top, + Bottom, } -impl Value for OakTrapdoorFacing { +impl Value for OakTrapdoorHalf { fn value(&self) -> usize { *self as usize } @@ -20507,11 +24833,13 @@ impl Value for OakTrapdoorFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum OakTrapdoorHalf { - Top, - Bottom, +pub enum OakTrapdoorFacing { + North, + South, + West, + East, } -impl Value for OakTrapdoorHalf { +impl Value for OakTrapdoorFacing { fn value(&self) -> usize { *self as usize } @@ -20576,19 +24904,6 @@ impl Value for BirchTrapdoorFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum JungleTrapdoorHalf { - Top, - Bottom, -} -impl Value for JungleTrapdoorHalf { - fn value(&self) -> usize { - *self as usize - } - fn from_value(val: usize) -> Option { - Self::from_usize(val) - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum JungleTrapdoorFacing { North, South, @@ -20604,13 +24919,11 @@ impl Value for JungleTrapdoorFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum AcaciaTrapdoorFacing { - North, - South, - West, - East, +pub enum JungleTrapdoorHalf { + Top, + Bottom, } -impl Value for AcaciaTrapdoorFacing { +impl Value for JungleTrapdoorHalf { fn value(&self) -> usize { *self as usize } @@ -20632,6 +24945,21 @@ impl Value for AcaciaTrapdoorHalf { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] +pub enum AcaciaTrapdoorFacing { + North, + South, + West, + East, +} +impl Value for AcaciaTrapdoorFacing { + fn value(&self) -> usize { + *self as usize + } + fn from_value(val: usize) -> Option { + Self::from_usize(val) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum DarkOakTrapdoorFacing { North, South, @@ -20793,13 +25121,14 @@ impl Value for StoneBrickStairsShape { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum NetherBrickStairsFacing { - North, - South, - West, - East, +pub enum NetherBrickStairsShape { + Straight, + InnerLeft, + InnerRight, + OuterLeft, + OuterRight, } -impl Value for NetherBrickStairsFacing { +impl Value for NetherBrickStairsShape { fn value(&self) -> usize { *self as usize } @@ -20821,14 +25150,13 @@ impl Value for NetherBrickStairsHalf { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum NetherBrickStairsShape { - Straight, - InnerLeft, - InnerRight, - OuterLeft, - OuterRight, +pub enum NetherBrickStairsFacing { + North, + South, + West, + East, } -impl Value for NetherBrickStairsShape { +impl Value for NetherBrickStairsFacing { fn value(&self) -> usize { *self as usize } @@ -20867,6 +25195,19 @@ impl Value for CocoaFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] +pub enum SandstoneStairsHalf { + Top, + Bottom, +} +impl Value for SandstoneStairsHalf { + fn value(&self) -> usize { + *self as usize + } + fn from_value(val: usize) -> Option { + Self::from_usize(val) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum SandstoneStairsFacing { North, South, @@ -20898,19 +25239,6 @@ impl Value for SandstoneStairsShape { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum SandstoneStairsHalf { - Top, - Bottom, -} -impl Value for SandstoneStairsHalf { - fn value(&self) -> usize { - *self as usize - } - fn from_value(val: usize) -> Option { - Self::from_usize(val) - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum EnderChestFacing { North, South, @@ -20956,22 +25284,6 @@ impl Value for SpruceStairsFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum SpruceStairsShape { - Straight, - InnerLeft, - InnerRight, - OuterLeft, - OuterRight, -} -impl Value for SpruceStairsShape { - fn value(&self) -> usize { - *self as usize - } - fn from_value(val: usize) -> Option { - Self::from_usize(val) - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum SpruceStairsHalf { Top, Bottom, @@ -20985,13 +25297,14 @@ impl Value for SpruceStairsHalf { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum BirchStairsFacing { - North, - South, - West, - East, +pub enum SpruceStairsShape { + Straight, + InnerLeft, + InnerRight, + OuterLeft, + OuterRight, } -impl Value for BirchStairsFacing { +impl Value for SpruceStairsShape { fn value(&self) -> usize { *self as usize } @@ -21029,6 +25342,21 @@ impl Value for BirchStairsHalf { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] +pub enum BirchStairsFacing { + North, + South, + West, + East, +} +impl Value for BirchStairsFacing { + fn value(&self) -> usize { + *self as usize + } + fn from_value(val: usize) -> Option { + Self::from_usize(val) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum JungleStairsFacing { North, South, @@ -21090,12 +25418,13 @@ impl Value for CommandBlockFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum OakButtonFace { - Floor, - Wall, - Ceiling, +pub enum OakButtonFacing { + North, + South, + West, + East, } -impl Value for OakButtonFace { +impl Value for OakButtonFacing { fn value(&self) -> usize { *self as usize } @@ -21104,13 +25433,12 @@ impl Value for OakButtonFace { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum OakButtonFacing { - North, - South, - West, - East, +pub enum OakButtonFace { + Floor, + Wall, + Ceiling, } -impl Value for OakButtonFacing { +impl Value for OakButtonFace { fn value(&self) -> usize { *self as usize } @@ -21177,6 +25505,20 @@ impl Value for BirchButtonFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] +pub enum JungleButtonFace { + Floor, + Wall, + Ceiling, +} +impl Value for JungleButtonFace { + fn value(&self) -> usize { + *self as usize + } + fn from_value(val: usize) -> Option { + Self::from_usize(val) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum JungleButtonFacing { North, South, @@ -21192,20 +25534,6 @@ impl Value for JungleButtonFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum JungleButtonFace { - Floor, - Wall, - Ceiling, -} -impl Value for JungleButtonFace { - fn value(&self) -> usize { - *self as usize - } - fn from_value(val: usize) -> Option { - Self::from_usize(val) - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum AcaciaButtonFacing { North, South, @@ -21428,13 +25756,11 @@ impl Value for TrappedChestFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum ComparatorFacing { - North, - South, - West, - East, +pub enum ComparatorMode { + Compare, + Subtract, } -impl Value for ComparatorFacing { +impl Value for ComparatorMode { fn value(&self) -> usize { *self as usize } @@ -21443,11 +25769,13 @@ impl Value for ComparatorFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum ComparatorMode { - Compare, - Subtract, +pub enum ComparatorFacing { + North, + South, + West, + East, } -impl Value for ComparatorMode { +impl Value for ComparatorFacing { fn value(&self) -> usize { *self as usize } @@ -21486,21 +25814,6 @@ impl Value for QuartzPillarAxis { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum QuartzStairsFacing { - North, - South, - West, - East, -} -impl Value for QuartzStairsFacing { - fn value(&self) -> usize { - *self as usize - } - fn from_value(val: usize) -> Option { - Self::from_usize(val) - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum QuartzStairsShape { Straight, InnerLeft, @@ -21530,6 +25843,21 @@ impl Value for QuartzStairsHalf { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] +pub enum QuartzStairsFacing { + North, + South, + West, + East, +} +impl Value for QuartzStairsFacing { + fn value(&self) -> usize { + *self as usize + } + fn from_value(val: usize) -> Option { + Self::from_usize(val) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum ActivatorRailShape { NorthSouth, EastWest, @@ -21608,14 +25936,11 @@ impl Value for AcaciaStairsShape { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum DarkOakStairsShape { - Straight, - InnerLeft, - InnerRight, - OuterLeft, - OuterRight, +pub enum DarkOakStairsHalf { + Top, + Bottom, } -impl Value for DarkOakStairsShape { +impl Value for DarkOakStairsHalf { fn value(&self) -> usize { *self as usize } @@ -21639,11 +25964,14 @@ impl Value for DarkOakStairsFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum DarkOakStairsHalf { - Top, - Bottom, +pub enum DarkOakStairsShape { + Straight, + InnerLeft, + InnerRight, + OuterLeft, + OuterRight, } -impl Value for DarkOakStairsHalf { +impl Value for DarkOakStairsShape { fn value(&self) -> usize { *self as usize } @@ -21693,6 +26021,21 @@ impl Value for PrismarineStairsHalf { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] +pub enum PrismarineStairsFacing { + North, + South, + West, + East, +} +impl Value for PrismarineStairsFacing { + fn value(&self) -> usize { + *self as usize + } + fn from_value(val: usize) -> Option { + Self::from_usize(val) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum PrismarineStairsShape { Straight, InnerLeft, @@ -21709,13 +26052,13 @@ impl Value for PrismarineStairsShape { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum PrismarineStairsFacing { +pub enum PrismarineBrickStairsFacing { North, South, West, East, } -impl Value for PrismarineStairsFacing { +impl Value for PrismarineBrickStairsFacing { fn value(&self) -> usize { *self as usize } @@ -21753,13 +26096,11 @@ impl Value for PrismarineBrickStairsShape { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum PrismarineBrickStairsFacing { - North, - South, - West, - East, +pub enum DarkPrismarineStairsHalf { + Top, + Bottom, } -impl Value for PrismarineBrickStairsFacing { +impl Value for DarkPrismarineStairsHalf { fn value(&self) -> usize { *self as usize } @@ -21768,11 +26109,14 @@ impl Value for PrismarineBrickStairsFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum DarkPrismarineStairsHalf { - Top, - Bottom, +pub enum DarkPrismarineStairsShape { + Straight, + InnerLeft, + InnerRight, + OuterLeft, + OuterRight, } -impl Value for DarkPrismarineStairsHalf { +impl Value for DarkPrismarineStairsShape { fn value(&self) -> usize { *self as usize } @@ -21796,22 +26140,6 @@ impl Value for DarkPrismarineStairsFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum DarkPrismarineStairsShape { - Straight, - InnerLeft, - InnerRight, - OuterLeft, - OuterRight, -} -impl Value for DarkPrismarineStairsShape { - fn value(&self) -> usize { - *self as usize - } - fn from_value(val: usize) -> Option { - Self::from_usize(val) - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum PrismarineSlabType { Top, Bottom, @@ -22186,11 +26514,14 @@ impl Value for BlackWallBannerFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum RedSandstoneStairsHalf { - Top, - Bottom, +pub enum RedSandstoneStairsShape { + Straight, + InnerLeft, + InnerRight, + OuterLeft, + OuterRight, } -impl Value for RedSandstoneStairsHalf { +impl Value for RedSandstoneStairsShape { fn value(&self) -> usize { *self as usize } @@ -22199,14 +26530,11 @@ impl Value for RedSandstoneStairsHalf { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum RedSandstoneStairsShape { - Straight, - InnerLeft, - InnerRight, - OuterLeft, - OuterRight, +pub enum RedSandstoneStairsHalf { + Top, + Bottom, } -impl Value for RedSandstoneStairsShape { +impl Value for RedSandstoneStairsHalf { fn value(&self) -> usize { *self as usize } @@ -22529,11 +26857,11 @@ impl Value for DarkOakFenceGateFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum SpruceDoorHalf { - Upper, - Lower, +pub enum SpruceDoorHinge { + Left, + Right, } -impl Value for SpruceDoorHalf { +impl Value for SpruceDoorHinge { fn value(&self) -> usize { *self as usize } @@ -22557,11 +26885,11 @@ impl Value for SpruceDoorFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum SpruceDoorHinge { - Left, - Right, +pub enum SpruceDoorHalf { + Upper, + Lower, } -impl Value for SpruceDoorHinge { +impl Value for SpruceDoorHalf { fn value(&self) -> usize { *self as usize } @@ -22570,13 +26898,11 @@ impl Value for SpruceDoorHinge { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum BirchDoorFacing { - North, - South, - West, - East, +pub enum BirchDoorHalf { + Upper, + Lower, } -impl Value for BirchDoorFacing { +impl Value for BirchDoorHalf { fn value(&self) -> usize { *self as usize } @@ -22598,11 +26924,13 @@ impl Value for BirchDoorHinge { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum BirchDoorHalf { - Upper, - Lower, +pub enum BirchDoorFacing { + North, + South, + West, + East, } -impl Value for BirchDoorHalf { +impl Value for BirchDoorFacing { fn value(&self) -> usize { *self as usize } @@ -22626,19 +26954,6 @@ impl Value for JungleDoorFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum JungleDoorHalf { - Upper, - Lower, -} -impl Value for JungleDoorHalf { - fn value(&self) -> usize { - *self as usize - } - fn from_value(val: usize) -> Option { - Self::from_usize(val) - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum JungleDoorHinge { Left, Right, @@ -22652,11 +26967,11 @@ impl Value for JungleDoorHinge { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum AcaciaDoorHalf { +pub enum JungleDoorHalf { Upper, Lower, } -impl Value for AcaciaDoorHalf { +impl Value for JungleDoorHalf { fn value(&self) -> usize { *self as usize } @@ -22680,6 +26995,19 @@ impl Value for AcaciaDoorFacing { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] +pub enum AcaciaDoorHalf { + Upper, + Lower, +} +impl Value for AcaciaDoorHalf { + fn value(&self) -> usize { + *self as usize + } + fn from_value(val: usize) -> Option { + Self::from_usize(val) + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] pub enum AcaciaDoorHinge { Left, Right, @@ -22778,14 +27106,13 @@ impl Value for PurpurStairsHalf { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum PurpurStairsShape { - Straight, - InnerLeft, - InnerRight, - OuterLeft, - OuterRight, +pub enum PurpurStairsFacing { + North, + South, + West, + East, } -impl Value for PurpurStairsShape { +impl Value for PurpurStairsFacing { fn value(&self) -> usize { *self as usize } @@ -22794,13 +27121,14 @@ impl Value for PurpurStairsShape { } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, ToSnakeCase, FromSnakeCase, FromPrimitive)] -pub enum PurpurStairsFacing { - North, - South, - West, - East, +pub enum PurpurStairsShape { + Straight, + InnerLeft, + InnerRight, + OuterLeft, + OuterRight, } -impl Value for PurpurStairsFacing { +impl Value for PurpurStairsShape { fn value(&self) -> usize { *self as usize } diff --git a/blocks/src/lib.rs b/blocks/src/lib.rs index 0a3193974..5303932a1 100644 --- a/blocks/src/lib.rs +++ b/blocks/src/lib.rs @@ -253,4 +253,12 @@ mod tests { assert_eq!(block.native_state_id(), id); } } + + #[test] + fn test_default_props() { + assert_eq!( + Block::from_name_and_default_props("minecraft:grass_block").unwrap(), + Block::GrassBlock(GrassBlockData { snowy: false }) + ); + } } diff --git a/generator/Cargo.toml b/generator/Cargo.toml index b797d6388..a710abcef 100644 --- a/generator/Cargo.toml +++ b/generator/Cargo.toml @@ -16,6 +16,6 @@ failure = "0.1.5" derive_deref = "1.1.0" indexmap = { version = "1.1.0", features = ["serde-1"] } quote = "1.0.2" -syn = "1.0.5" +syn = { version = "1.0.5", features = ["full"] } heck = "0.3.1" proc-macro2 = "1.0.2" \ No newline at end of file diff --git a/generator/blocks.sh b/generator/blocks.sh index 7129bab07..be074feed 100755 --- a/generator/blocks.sh +++ b/generator/blocks.sh @@ -2,8 +2,8 @@ echo "Generating block ID mappings and code" -GENERATOR="cargo run --release --bin feather_generator -- " +GENERATOR="cargo run --release --bin feather-generator -- " ${GENERATOR} native-block-mappings -i data/blocks/1.13.2.json -o ../blocks/data/1.13.2.dat -v 1.13.2 -p 404 -${GENERATOR} block-mappings -i data/blocks/1.14.4.json -n data/blocks/1.13.2.json -o ../blocks/data/1.14.4.dat -v 1.14.4 -p 498 +#${GENERATOR} block-mappings -i data/blocks/1.14.4.json -n data/blocks/1.13.2.json -o ../blocks/data/1.14.4.dat -v 1.14.4 -p 498 ${GENERATOR} block-rust -i data/blocks/1.13.2.json -o ../blocks/src/blocks.rs \ No newline at end of file diff --git a/generator/items.sh b/generator/items.sh index 832a671eb..a05da6aae 100755 --- a/generator/items.sh +++ b/generator/items.sh @@ -1,6 +1,6 @@ #!/usr/bin/env bash -GENERATOR="cargo run --release --bin feather_generator -- " +GENERATOR="cargo run --release --bin feather-generator -- " ${GENERATOR} item-mappings -i data/items/1.13.2.json -o ../items/data/1.13.2.dat ${GENERATOR} item-rust -i data/items/1.13.2.json -o ../items/src/item.rs diff --git a/generator/src/rust.rs b/generator/src/rust.rs index 60a15163b..91654f783 100644 --- a/generator/src/rust.rs +++ b/generator/src/rust.rs @@ -3,7 +3,9 @@ //! written - but at least it works. use super::*; +use quote::ToTokens; use std::process::Command; +use syn::LitInt; pub fn generate_rust_code(input: &str, output: &str) -> Result<(), Error> { info!( @@ -44,6 +46,7 @@ pub fn generate_rust_code(input: &str, output: &str) -> Result<(), Error> { let internal_id_offsets = generate_internal_id_offsets(&report); let internal_state_id_fn = generate_internal_state_id_fn(); let from_name_and_props_fn = generate_from_name_and_props_fn(&report); + let from_name_and_default_props_fn = generate_from_and_default_props_fn(&report); let from_internal_state_id_fn = generate_from_internal_state_id_fn(&report); let block = quote! { @@ -61,6 +64,7 @@ pub fn generate_rust_code(input: &str, output: &str) -> Result<(), Error> { #internal_id_data_offset_fn #internal_state_id_fn #from_name_and_props_fn + #from_name_and_default_props_fn #from_internal_state_id_fn } }; @@ -196,8 +200,8 @@ fn generate_block_code( // If block has properties, we need to create a // data struct for the block and include it in the // enum variant. - if let Some(props) = block.properties.clone() { - create_block_data_struct(&variant_name, &props, property_enums, data_structs); + if block.properties.is_some() { + create_block_data_struct(&variant_name, &block, property_enums, data_structs); let data_struct_ident = Ident::new(&format!("{}Data", variant_name), Span::call_site()); enum_entries.push(quote! { #variant_ident(#data_struct_ident) @@ -218,13 +222,17 @@ fn generate_block_code( fn create_block_data_struct( variant_name: &str, - props: &BlockProperties, + block: &Block, property_enums: &mut Vec, data_structs: &mut Vec, ) { let mut data_struct_entries = vec![]; let mut from_map_entries = vec![]; let mut to_map_entries = vec![]; + let mut default_impl_entries = vec![]; + + let props = &block.properties.as_ref().unwrap(); + let states = &block.states; for (prop_name_str, possible_values) in &props.props { let ty = PropValueType::guess_from_value(&possible_values[0]); @@ -262,6 +270,19 @@ fn create_block_data_struct( to_map_entries.push(quote! { m.insert(#prop_name_str.to_string(), self.#field_name.to_snake_case()); }); + + // Find default state and create an entry in the Default impl for it + let default_state = states.iter().find(|state| state.default).unwrap(); + + let default_value = { + let value_str = &default_state.properties.as_ref().unwrap().props[prop_name_str]; + + value_from_string(ty, variant_name, prop_name_str, value_str) + }; + + default_impl_entries.push(quote! { + #field_name: #default_value, + }); } let data_ident = Ident::new(&format!("{}Data", variant_name), Span::call_site()); @@ -288,22 +309,53 @@ fn create_block_data_struct( } } + impl Default for #data_ident { + fn default() -> Self { + Self { + #(#default_impl_entries)* + } + } + } + #value_impl }; data_structs.push(data_struct); } +fn value_from_string( + value_ty: PropValueType, + variant_name: &str, + prop_name: &str, + value_str: &str, +) -> Box { + match value_ty { + PropValueType::I32 => Box::new(LitInt::new(value_str, Span::call_site())), + PropValueType::Bool => Box::new(Ident::new(value_str, Span::call_site())), + PropValueType::Enum => { + let enum_ident = enum_ident(variant_name, prop_name); + let value_ident = Ident::new(&value_str.to_camel_case(), Span::call_site()); + Box::new(quote! { + #enum_ident::#value_ident + }) + } + } +} + +fn enum_ident(variant_name: &str, prop_name: &str) -> Ident { + Ident::new( + &format!("{}{}", variant_name, prop_name.to_camel_case()), + Span::call_site(), + ) +} + fn create_property_enum( variant_name: &str, prop_name: &str, possible_values: &[String], property_enums: &mut Vec, ) { - let enum_ident = Ident::new( - &format!("{}{}", variant_name, prop_name.to_camel_case()), - Span::call_site(), - ); + let enum_ident = enum_ident(variant_name, prop_name); let mut enum_variants = vec![]; @@ -654,3 +706,41 @@ fn generate_from_name_and_props_fn(report: &BlockReport) -> TokenStream { }; result } + +/// Generates the `from_name_and_default_props` function. +fn generate_from_and_default_props_fn(report: &BlockReport) -> TokenStream { + // More duplicate code than ever before! + // This entire file should probably be rewritten at some point. + let mut match_arms = vec![]; + + for (block_name, block) in &report.blocks { + let variant_name = block_name[10..].to_camel_case(); + let variant_ident = Ident::new(&variant_name, Span::call_site()); + + if block.properties.is_some() { + let data_struct_str = format!("{}Data", variant_name); + let data_struct_ident = Ident::new(&data_struct_str, Span::call_site()); + + match_arms.push(quote! { + #block_name => { + let data = #data_struct_ident::default(); + Some(Block::#variant_ident(data)) + } + }); + } else { + match_arms.push(quote! { + #block_name => Some(Block::#variant_ident) + }); + } + } + + let result = quote! { + pub fn from_name_and_default_props(name: &str) -> Option { + match name { + #(#match_arms ,)* + _ => None, + } + } + }; + result +}