diff --git a/src/block/BlockFactory.php b/src/block/BlockFactory.php
index 22aede663..5ee4c0be8 100644
--- a/src/block/BlockFactory.php
+++ b/src/block/BlockFactory.php
@@ -52,6 +52,7 @@ use pocketmine\block\tile\Skull as TileSkull;
 use pocketmine\block\tile\Smoker as TileSmoker;
 use pocketmine\block\utils\InvalidBlockStateException;
 use pocketmine\block\utils\TreeType;
+use pocketmine\block\utils\WoodType;
 use pocketmine\item\Item;
 use pocketmine\item\ToolTier;
 use pocketmine\utils\AssumptionFailedError;
@@ -458,29 +459,33 @@ class BlockFactory{
 
 		foreach(TreeType::getAll() as $treeType){
 			$name = $treeType->getDisplayName();
-			$this->register(new Planks(BlockLegacyIdHelper::getWoodenPlanksIdentifier($treeType), $name . " Planks", $planksBreakInfo));
 			$this->register(new Sapling(BlockLegacyIdHelper::getSaplingIdentifier($treeType), $name . " Sapling", BreakInfo::instant(), $treeType));
-			$this->register(new WoodenFence(BlockLegacyIdHelper::getWoodenFenceIdentifier($treeType), $name . " Fence", $planksBreakInfo));
-			$this->register(new WoodenSlab(BlockLegacyIdHelper::getWoodenSlabIdentifier($treeType), $name, $planksBreakInfo));
-
 			$this->register(new Leaves(BlockLegacyIdHelper::getLeavesIdentifier($treeType), $name . " Leaves", $leavesBreakInfo, $treeType));
 
-			$this->register(new Wood(BlockLegacyIdHelper::getLogIdentifier($treeType), $name . " Log", $logBreakInfo, $treeType));
-			$this->register(new Wood(BlockLegacyIdHelper::getAllSidedLogIdentifier($treeType), $name . " Wood", $logBreakInfo, $treeType));
-
-			$this->register(new FenceGate(BlockLegacyIdHelper::getWoodenFenceGateIdentifier($treeType), $name . " Fence Gate", $planksBreakInfo));
-			$this->register(new WoodenStairs(BlockLegacyIdHelper::getWoodenStairsIdentifier($treeType), $name . " Stairs", $planksBreakInfo));
-			$this->register(new WoodenDoor(BlockLegacyIdHelper::getWoodenDoorIdentifier($treeType), $name . " Door", $woodenDoorBreakInfo));
-
-			$this->register(new WoodenButton(BlockLegacyIdHelper::getWoodenButtonIdentifier($treeType), $name . " Button", $woodenButtonBreakInfo));
-			$this->register(new WoodenPressurePlate(BlockLegacyIdHelper::getWoodenPressurePlateIdentifier($treeType), $name . " Pressure Plate", $woodenPressurePlateBreakInfo));
-			$this->register(new WoodenTrapdoor(BlockLegacyIdHelper::getWoodenTrapdoorIdentifier($treeType), $name . " Trapdoor", $woodenDoorBreakInfo));
-
 			[$floorSignId, $wallSignId, $signAsItem] = BlockLegacyIdHelper::getWoodenSignInfo($treeType);
 			$this->register(new FloorSign($floorSignId, $name . " Sign", $signBreakInfo, $signAsItem));
 			$this->register(new WallSign($wallSignId, $name . " Wall Sign", $signBreakInfo, $signAsItem));
 		}
 
+		foreach(WoodType::getAll() as $woodType){
+			$name = $woodType->getDisplayName();
+
+			$this->register(new Wood(BlockLegacyIdHelper::getLogIdentifier($woodType), $name . " " . ($woodType->getStandardLogSuffix() ?? "Log"), $logBreakInfo, $woodType));
+			$this->register(new Wood(BlockLegacyIdHelper::getAllSidedLogIdentifier($woodType), $name . " " . ($woodType->getAllSidedLogSuffix() ?? "Wood"), $logBreakInfo, $woodType));
+
+			$this->register(new Planks(BlockLegacyIdHelper::getWoodenPlanksIdentifier($woodType), $name . " Planks", $planksBreakInfo, $woodType));
+			$this->register(new WoodenFence(BlockLegacyIdHelper::getWoodenFenceIdentifier($woodType), $name . " Fence", $planksBreakInfo, $woodType));
+			$this->register(new WoodenSlab(BlockLegacyIdHelper::getWoodenSlabIdentifier($woodType), $name, $planksBreakInfo, $woodType));
+
+			$this->register(new FenceGate(BlockLegacyIdHelper::getWoodenFenceGateIdentifier($woodType), $name . " Fence Gate", $planksBreakInfo, $woodType));
+			$this->register(new WoodenStairs(BlockLegacyIdHelper::getWoodenStairsIdentifier($woodType), $name . " Stairs", $planksBreakInfo, $woodType));
+			$this->register(new WoodenDoor(BlockLegacyIdHelper::getWoodenDoorIdentifier($woodType), $name . " Door", $woodenDoorBreakInfo, $woodType));
+
+			$this->register(new WoodenButton(BlockLegacyIdHelper::getWoodenButtonIdentifier($woodType), $name . " Button", $woodenButtonBreakInfo, $woodType));
+			$this->register(new WoodenPressurePlate(BlockLegacyIdHelper::getWoodenPressurePlateIdentifier($woodType), $name . " Pressure Plate", $woodenPressurePlateBreakInfo, $woodType));
+			$this->register(new WoodenTrapdoor(BlockLegacyIdHelper::getWoodenTrapdoorIdentifier($woodType), $name . " Trapdoor", $woodenDoorBreakInfo, $woodType));
+		}
+
 		$sandstoneBreakInfo = new BreakInfo(0.8, ToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel());
 		$this->register(new Stair(new BID(Ids::RED_SANDSTONE_STAIRS), "Red Sandstone Stairs", $sandstoneBreakInfo));
 		$this->register(new Stair(new BID(Ids::SMOOTH_RED_SANDSTONE_STAIRS), "Smooth Red Sandstone Stairs", $sandstoneBreakInfo));
diff --git a/src/block/BlockLegacyIdHelper.php b/src/block/BlockLegacyIdHelper.php
index 7f16cb4b1..462257252 100644
--- a/src/block/BlockLegacyIdHelper.php
+++ b/src/block/BlockLegacyIdHelper.php
@@ -27,67 +27,83 @@ use pocketmine\block\BlockIdentifier as BID;
 use pocketmine\block\BlockTypeIds as Ids;
 use pocketmine\block\tile\Sign as TileSign;
 use pocketmine\block\utils\TreeType;
+use pocketmine\block\utils\WoodType;
 use pocketmine\item\VanillaItems;
 use pocketmine\utils\AssumptionFailedError;
 
 final class BlockLegacyIdHelper{
 
-	public static function getWoodenPlanksIdentifier(TreeType $treeType) : BID{
-		return new BID(match($treeType->id()){
-			TreeType::OAK()->id() => Ids::OAK_PLANKS,
-			TreeType::SPRUCE()->id() => Ids::SPRUCE_PLANKS,
-			TreeType::BIRCH()->id() => Ids::BIRCH_PLANKS,
-			TreeType::JUNGLE()->id() => Ids::JUNGLE_PLANKS,
-			TreeType::ACACIA()->id() => Ids::ACACIA_PLANKS,
-			TreeType::DARK_OAK()->id() => Ids::DARK_OAK_PLANKS,
+	public static function getWoodenPlanksIdentifier(WoodType $type) : BID{
+		return new BID(match($type->id()){
+			WoodType::OAK()->id() => Ids::OAK_PLANKS,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_PLANKS,
+			WoodType::BIRCH()->id() => Ids::BIRCH_PLANKS,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_PLANKS,
+			WoodType::ACACIA()->id() => Ids::ACACIA_PLANKS,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_PLANKS,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_PLANKS,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_PLANKS,
+			WoodType::WARPED()->id() => Ids::WARPED_PLANKS,
 			default => throw new AssumptionFailedError("All tree types should be covered")
 		});
 	}
 
-	public static function getWoodenFenceIdentifier(TreeType $treeType) : BID{
-		return new BID(match($treeType->id()){
-			TreeType::OAK()->id() => Ids::OAK_FENCE,
-			TreeType::SPRUCE()->id() => Ids::SPRUCE_FENCE,
-			TreeType::BIRCH()->id() => Ids::BIRCH_FENCE,
-			TreeType::JUNGLE()->id() => Ids::JUNGLE_FENCE,
-			TreeType::ACACIA()->id() => Ids::ACACIA_FENCE,
-			TreeType::DARK_OAK()->id() => Ids::DARK_OAK_FENCE,
+	public static function getWoodenFenceIdentifier(WoodType $type) : BID{
+		return new BID(match($type->id()){
+			WoodType::OAK()->id() => Ids::OAK_FENCE,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_FENCE,
+			WoodType::BIRCH()->id() => Ids::BIRCH_FENCE,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_FENCE,
+			WoodType::ACACIA()->id() => Ids::ACACIA_FENCE,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_FENCE,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_FENCE,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_FENCE,
+			WoodType::WARPED()->id() => Ids::WARPED_FENCE,
 			default => throw new AssumptionFailedError("All tree types should be covered")
 		});
 	}
 
-	public static function getWoodenSlabIdentifier(TreeType $treeType) : BID{
-		return new BID(match($treeType->id()){
-			TreeType::OAK()->id() => Ids::OAK_SLAB,
-			TreeType::SPRUCE()->id() => Ids::SPRUCE_SLAB,
-			TreeType::BIRCH()->id() => Ids::BIRCH_SLAB,
-			TreeType::JUNGLE()->id() => Ids::JUNGLE_SLAB,
-			TreeType::ACACIA()->id() => Ids::ACACIA_SLAB,
-			TreeType::DARK_OAK()->id() => Ids::DARK_OAK_SLAB,
+	public static function getWoodenSlabIdentifier(WoodType $type) : BID{
+		return new BID(match($type->id()){
+			WoodType::OAK()->id() => Ids::OAK_SLAB,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_SLAB,
+			WoodType::BIRCH()->id() => Ids::BIRCH_SLAB,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_SLAB,
+			WoodType::ACACIA()->id() => Ids::ACACIA_SLAB,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_SLAB,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_SLAB,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_SLAB,
+			WoodType::WARPED()->id() => Ids::WARPED_SLAB,
 			default => throw new AssumptionFailedError("All tree types should be covered")
 		});
 	}
 
-	public static function getLogIdentifier(TreeType $treeType) : BID{
+	public static function getLogIdentifier(WoodType $treeType) : BID{
 		return match($treeType->id()){
-			TreeType::OAK()->id() => new BID(Ids::OAK_LOG),
-			TreeType::SPRUCE()->id() => new BID(Ids::SPRUCE_LOG),
-			TreeType::BIRCH()->id() => new BID(Ids::BIRCH_LOG),
-			TreeType::JUNGLE()->id() => new BID(Ids::JUNGLE_LOG),
-			TreeType::ACACIA()->id() => new BID(Ids::ACACIA_LOG),
-			TreeType::DARK_OAK()->id() => new BID(Ids::DARK_OAK_LOG),
+			WoodType::OAK()->id() => new BID(Ids::OAK_LOG),
+			WoodType::SPRUCE()->id() => new BID(Ids::SPRUCE_LOG),
+			WoodType::BIRCH()->id() => new BID(Ids::BIRCH_LOG),
+			WoodType::JUNGLE()->id() => new BID(Ids::JUNGLE_LOG),
+			WoodType::ACACIA()->id() => new BID(Ids::ACACIA_LOG),
+			WoodType::DARK_OAK()->id() => new BID(Ids::DARK_OAK_LOG),
+			WoodType::MANGROVE()->id() => new BID(Ids::MANGROVE_LOG),
+			WoodType::CRIMSON()->id() => new BID(Ids::CRIMSON_STEM),
+			WoodType::WARPED()->id() => new BID(Ids::WARPED_STEM),
 			default => throw new AssumptionFailedError("All tree types should be covered")
 		};
 	}
 
-	public static function getAllSidedLogIdentifier(TreeType $treeType) : BID{
+	public static function getAllSidedLogIdentifier(WoodType $treeType) : BID{
 		return new BID(match($treeType->id()){
-			TreeType::OAK()->id() => Ids::OAK_WOOD,
-			TreeType::SPRUCE()->id() => Ids::SPRUCE_WOOD,
-			TreeType::BIRCH()->id() => Ids::BIRCH_WOOD,
-			TreeType::JUNGLE()->id() => Ids::JUNGLE_WOOD,
-			TreeType::ACACIA()->id() => Ids::ACACIA_WOOD,
-			TreeType::DARK_OAK()->id() => Ids::DARK_OAK_WOOD,
+			WoodType::OAK()->id() => Ids::OAK_WOOD,
+			WoodType::SPRUCE()->id() => Ids::SPRUCE_WOOD,
+			WoodType::BIRCH()->id() => Ids::BIRCH_WOOD,
+			WoodType::JUNGLE()->id() => Ids::JUNGLE_WOOD,
+			WoodType::ACACIA()->id() => Ids::ACACIA_WOOD,
+			WoodType::DARK_OAK()->id() => Ids::DARK_OAK_WOOD,
+			WoodType::MANGROVE()->id() => Ids::MANGROVE_WOOD,
+			WoodType::CRIMSON()->id() => Ids::CRIMSON_HYPHAE,
+			WoodType::WARPED()->id() => Ids::WARPED_HYPHAE,
 			default => throw new AssumptionFailedError("All tree types should be covered")
 		});
 	}
@@ -162,110 +178,146 @@ final class BlockLegacyIdHelper{
 		throw new AssumptionFailedError("Switch should cover all wood types");
 	}
 
-	public static function getWoodenTrapdoorIdentifier(TreeType $treeType) : BlockIdentifier{
+	public static function getWoodenTrapdoorIdentifier(WoodType $treeType) : BlockIdentifier{
 		switch($treeType->id()){
-			case TreeType::OAK()->id():
+			case WoodType::OAK()->id():
 				return new BID(Ids::OAK_TRAPDOOR);
-			case TreeType::SPRUCE()->id():
+			case WoodType::SPRUCE()->id():
 				return new BID(Ids::SPRUCE_TRAPDOOR);
-			case TreeType::BIRCH()->id():
+			case WoodType::BIRCH()->id():
 				return new BID(Ids::BIRCH_TRAPDOOR);
-			case TreeType::JUNGLE()->id():
+			case WoodType::JUNGLE()->id():
 				return new BID(Ids::JUNGLE_TRAPDOOR);
-			case TreeType::ACACIA()->id():
+			case WoodType::ACACIA()->id():
 				return new BID(Ids::ACACIA_TRAPDOOR);
-			case TreeType::DARK_OAK()->id():
+			case WoodType::DARK_OAK()->id():
 				return new BID(Ids::DARK_OAK_TRAPDOOR);
+			case WoodType::MANGROVE()->id():
+				return new BID(Ids::MANGROVE_TRAPDOOR);
+			case WoodType::CRIMSON()->id():
+				return new BID(Ids::CRIMSON_TRAPDOOR);
+			case WoodType::WARPED()->id():
+				return new BID(Ids::WARPED_TRAPDOOR);
 		}
 		throw new AssumptionFailedError("Switch should cover all wood types");
 	}
 
-	public static function getWoodenButtonIdentifier(TreeType $treeType) : BlockIdentifier{
+	public static function getWoodenButtonIdentifier(WoodType $treeType) : BlockIdentifier{
 		switch($treeType->id()){
-			case TreeType::OAK()->id():
+			case WoodType::OAK()->id():
 				return new BID(Ids::OAK_BUTTON);
-			case TreeType::SPRUCE()->id():
+			case WoodType::SPRUCE()->id():
 				return new BID(Ids::SPRUCE_BUTTON);
-			case TreeType::BIRCH()->id():
+			case WoodType::BIRCH()->id():
 				return new BID(Ids::BIRCH_BUTTON);
-			case TreeType::JUNGLE()->id():
+			case WoodType::JUNGLE()->id():
 				return new BID(Ids::JUNGLE_BUTTON);
-			case TreeType::ACACIA()->id():
+			case WoodType::ACACIA()->id():
 				return new BID(Ids::ACACIA_BUTTON);
-			case TreeType::DARK_OAK()->id():
+			case WoodType::DARK_OAK()->id():
 				return new BID(Ids::DARK_OAK_BUTTON);
+			case WoodType::MANGROVE()->id():
+				return new BID(Ids::MANGROVE_BUTTON);
+			case WoodType::CRIMSON()->id():
+				return new BID(Ids::CRIMSON_BUTTON);
+			case WoodType::WARPED()->id():
+				return new BID(Ids::WARPED_BUTTON);
 		}
 		throw new AssumptionFailedError("Switch should cover all wood types");
 	}
 
-	public static function getWoodenPressurePlateIdentifier(TreeType $treeType) : BlockIdentifier{
+	public static function getWoodenPressurePlateIdentifier(WoodType $treeType) : BlockIdentifier{
 		switch($treeType->id()){
-			case TreeType::OAK()->id():
+			case WoodType::OAK()->id():
 				return new BID(Ids::OAK_PRESSURE_PLATE);
-			case TreeType::SPRUCE()->id():
+			case WoodType::SPRUCE()->id():
 				return new BID(Ids::SPRUCE_PRESSURE_PLATE);
-			case TreeType::BIRCH()->id():
+			case WoodType::BIRCH()->id():
 				return new BID(Ids::BIRCH_PRESSURE_PLATE);
-			case TreeType::JUNGLE()->id():
+			case WoodType::JUNGLE()->id():
 				return new BID(Ids::JUNGLE_PRESSURE_PLATE);
-			case TreeType::ACACIA()->id():
+			case WoodType::ACACIA()->id():
 				return new BID(Ids::ACACIA_PRESSURE_PLATE);
-			case TreeType::DARK_OAK()->id():
+			case WoodType::DARK_OAK()->id():
 				return new BID(Ids::DARK_OAK_PRESSURE_PLATE);
+			case WoodType::MANGROVE()->id():
+				return new BID(Ids::MANGROVE_PRESSURE_PLATE);
+			case WoodType::CRIMSON()->id():
+				return new BID(Ids::CRIMSON_PRESSURE_PLATE);
+			case WoodType::WARPED()->id():
+				return new BID(Ids::WARPED_PRESSURE_PLATE);
 		}
 		throw new AssumptionFailedError("Switch should cover all wood types");
 	}
 
-	public static function getWoodenDoorIdentifier(TreeType $treeType) : BlockIdentifier{
+	public static function getWoodenDoorIdentifier(WoodType $treeType) : BlockIdentifier{
 		switch($treeType->id()){
-			case TreeType::OAK()->id():
+			case WoodType::OAK()->id():
 				return new BID(Ids::OAK_DOOR);
-			case TreeType::SPRUCE()->id():
+			case WoodType::SPRUCE()->id():
 				return new BID(Ids::SPRUCE_DOOR);
-			case TreeType::BIRCH()->id():
+			case WoodType::BIRCH()->id():
 				return new BID(Ids::BIRCH_DOOR);
-			case TreeType::JUNGLE()->id():
+			case WoodType::JUNGLE()->id():
 				return new BID(Ids::JUNGLE_DOOR);
-			case TreeType::ACACIA()->id():
+			case WoodType::ACACIA()->id():
 				return new BID(Ids::ACACIA_DOOR);
-			case TreeType::DARK_OAK()->id():
+			case WoodType::DARK_OAK()->id():
 				return new BID(Ids::DARK_OAK_DOOR);
+			case WoodType::MANGROVE()->id():
+				return new BID(Ids::MANGROVE_DOOR);
+			case WoodType::CRIMSON()->id():
+				return new BID(Ids::CRIMSON_DOOR);
+			case WoodType::WARPED()->id():
+				return new BID(Ids::WARPED_DOOR);
 		}
 		throw new AssumptionFailedError("Switch should cover all wood types");
 	}
 
-	public static function getWoodenFenceGateIdentifier(TreeType $treeType) : BlockIdentifier{
+	public static function getWoodenFenceGateIdentifier(WoodType $treeType) : BlockIdentifier{
 		switch($treeType->id()){
-			case TreeType::OAK()->id():
+			case WoodType::OAK()->id():
 				return new BID(Ids::OAK_FENCE_GATE);
-			case TreeType::SPRUCE()->id():
+			case WoodType::SPRUCE()->id():
 				return new BID(Ids::SPRUCE_FENCE_GATE);
-			case TreeType::BIRCH()->id():
+			case WoodType::BIRCH()->id():
 				return new BID(Ids::BIRCH_FENCE_GATE);
-			case TreeType::JUNGLE()->id():
+			case WoodType::JUNGLE()->id():
 				return new BID(Ids::JUNGLE_FENCE_GATE);
-			case TreeType::ACACIA()->id():
+			case WoodType::ACACIA()->id():
 				return new BID(Ids::ACACIA_FENCE_GATE);
-			case TreeType::DARK_OAK()->id():
+			case WoodType::DARK_OAK()->id():
 				return new BID(Ids::DARK_OAK_FENCE_GATE);
+			case WoodType::MANGROVE()->id():
+				return new BID(Ids::MANGROVE_FENCE_GATE);
+			case WoodType::CRIMSON()->id():
+				return new BID(Ids::CRIMSON_FENCE_GATE);
+			case WoodType::WARPED()->id():
+				return new BID(Ids::WARPED_FENCE_GATE);
 		}
 		throw new AssumptionFailedError("Switch should cover all wood types");
 	}
 
-	public static function getWoodenStairsIdentifier(TreeType $treeType) : BlockIdentifier{
+	public static function getWoodenStairsIdentifier(WoodType $treeType) : BlockIdentifier{
 		switch($treeType->id()){
-			case TreeType::OAK()->id():
+			case WoodType::OAK()->id():
 				return new BID(Ids::OAK_STAIRS);
-			case TreeType::SPRUCE()->id():
+			case WoodType::SPRUCE()->id():
 				return new BID(Ids::SPRUCE_STAIRS);
-			case TreeType::BIRCH()->id():
+			case WoodType::BIRCH()->id():
 				return new BID(Ids::BIRCH_STAIRS);
-			case TreeType::JUNGLE()->id():
+			case WoodType::JUNGLE()->id():
 				return new BID(Ids::JUNGLE_STAIRS);
-			case TreeType::ACACIA()->id():
+			case WoodType::ACACIA()->id():
 				return new BID(Ids::ACACIA_STAIRS);
-			case TreeType::DARK_OAK()->id():
+			case WoodType::DARK_OAK()->id():
 				return new BID(Ids::DARK_OAK_STAIRS);
+			case WoodType::MANGROVE()->id():
+				return new BID(Ids::MANGROVE_STAIRS);
+			case WoodType::CRIMSON()->id():
+				return new BID(Ids::CRIMSON_STAIRS);
+			case WoodType::WARPED()->id():
+				return new BID(Ids::WARPED_STAIRS);
 		}
 		throw new AssumptionFailedError("Switch should cover all wood types");
 	}
diff --git a/src/block/BlockTypeIds.php b/src/block/BlockTypeIds.php
index e8dfc65aa..deca05b42 100644
--- a/src/block/BlockTypeIds.php
+++ b/src/block/BlockTypeIds.php
@@ -614,5 +614,39 @@ final class BlockTypeIds{
 	public const CHISELED_NETHER_BRICKS = 10587;
 	public const CRACKED_NETHER_BRICKS = 10588;
 
-	public const FIRST_UNUSED_BLOCK_ID = 10589;
+	public const MANGROVE_PLANKS = 10595;
+	public const CRIMSON_PLANKS = 10596;
+	public const WARPED_PLANKS = 10597;
+	public const MANGROVE_FENCE = 10598;
+	public const CRIMSON_FENCE = 10599;
+	public const WARPED_FENCE = 10600;
+	public const MANGROVE_SLAB = 10601;
+	public const CRIMSON_SLAB = 10602;
+	public const WARPED_SLAB = 10603;
+	public const MANGROVE_LOG = 10604;
+	public const CRIMSON_STEM = 10605;
+	public const WARPED_STEM = 10606;
+	public const MANGROVE_WOOD = 10607;
+	public const CRIMSON_HYPHAE = 10608;
+	public const WARPED_HYPHAE = 10609;
+	public const MANGROVE_TRAPDOOR = 10610;
+	public const CRIMSON_TRAPDOOR = 10611;
+	public const WARPED_TRAPDOOR = 10612;
+	public const MANGROVE_BUTTON = 10613;
+	public const CRIMSON_BUTTON = 10614;
+	public const WARPED_BUTTON = 10615;
+	public const MANGROVE_PRESSURE_PLATE = 10616;
+	public const CRIMSON_PRESSURE_PLATE = 10617;
+	public const WARPED_PRESSURE_PLATE = 10618;
+	public const MANGROVE_DOOR = 10619;
+	public const CRIMSON_DOOR = 10620;
+	public const WARPED_DOOR = 10621;
+	public const MANGROVE_FENCE_GATE = 10622;
+	public const CRIMSON_FENCE_GATE = 10623;
+	public const WARPED_FENCE_GATE = 10624;
+	public const MANGROVE_STAIRS = 10625;
+	public const CRIMSON_STAIRS = 10626;
+	public const WARPED_STAIRS = 10627;
+
+	public const FIRST_UNUSED_BLOCK_ID = 10628;
 }
diff --git a/src/block/CocoaBlock.php b/src/block/CocoaBlock.php
index 1e06517fc..f0f9b2464 100644
--- a/src/block/CocoaBlock.php
+++ b/src/block/CocoaBlock.php
@@ -25,7 +25,7 @@ namespace pocketmine\block;
 
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
-use pocketmine\block\utils\TreeType;
+use pocketmine\block\utils\WoodType;
 use pocketmine\data\runtime\block\BlockDataReader;
 use pocketmine\data\runtime\block\BlockDataWriter;
 use pocketmine\event\block\BlockGrowEvent;
@@ -89,7 +89,7 @@ class CocoaBlock extends Transparent{
 	}
 
 	private function canAttachTo(Block $block) : bool{
-		return $block instanceof Wood && $block->getTreeType()->equals(TreeType::JUNGLE());
+		return $block instanceof Wood && $block->getWoodType()->equals(WoodType::JUNGLE());
 	}
 
 	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
diff --git a/src/block/FenceGate.php b/src/block/FenceGate.php
index 6f5f1c9a4..b9bc95e18 100644
--- a/src/block/FenceGate.php
+++ b/src/block/FenceGate.php
@@ -25,6 +25,7 @@ namespace pocketmine\block;
 
 use pocketmine\block\utils\HorizontalFacingTrait;
 use pocketmine\block\utils\SupportType;
+use pocketmine\block\utils\WoodTypeTrait;
 use pocketmine\data\runtime\block\BlockDataReader;
 use pocketmine\data\runtime\block\BlockDataWriter;
 use pocketmine\item\Item;
@@ -36,6 +37,7 @@ use pocketmine\world\BlockTransaction;
 use pocketmine\world\sound\DoorSound;
 
 class FenceGate extends Transparent{
+	use WoodTypeTrait;
 	use HorizontalFacingTrait;
 
 	protected bool $open = false;
@@ -126,10 +128,10 @@ class FenceGate extends Transparent{
 	}
 
 	public function getFlameEncouragement() : int{
-		return 5;
+		return $this->woodType->isFlammable() ? 5 : 0;
 	}
 
 	public function getFlammability() : int{
-		return 20;
+		return $this->woodType->isFlammable() ? 20 : 0;
 	}
 }
diff --git a/src/block/Planks.php b/src/block/Planks.php
index 9f780694a..23c9fe4a8 100644
--- a/src/block/Planks.php
+++ b/src/block/Planks.php
@@ -23,17 +23,26 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\WoodType;
+use pocketmine\block\utils\WoodTypeTrait;
+
 class Planks extends Opaque{
+	use WoodTypeTrait;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo, WoodType $woodType){
+		$this->woodType = $woodType;
+		parent::__construct($idInfo, $name, $breakInfo);
+	}
 
 	public function getFuelTime() : int{
 		return 300;
 	}
 
 	public function getFlameEncouragement() : int{
-		return 5;
+		return $this->woodType->isFlammable() ? 5 : 0;
 	}
 
 	public function getFlammability() : int{
-		return 20;
+		return $this->woodType->isFlammable() ? 20 : 0;
 	}
 }
diff --git a/src/block/VanillaBlocks.php b/src/block/VanillaBlocks.php
index 3bbce12ce..ae1852c0d 100644
--- a/src/block/VanillaBlocks.php
+++ b/src/block/VanillaBlocks.php
@@ -143,6 +143,17 @@ use pocketmine\utils\CloningRegistryTrait;
  * @method static Opaque CRACKED_POLISHED_BLACKSTONE_BRICKS()
  * @method static Opaque CRACKED_STONE_BRICKS()
  * @method static CraftingTable CRAFTING_TABLE()
+ * @method static WoodenButton CRIMSON_BUTTON()
+ * @method static WoodenDoor CRIMSON_DOOR()
+ * @method static WoodenFence CRIMSON_FENCE()
+ * @method static FenceGate CRIMSON_FENCE_GATE()
+ * @method static Wood CRIMSON_HYPHAE()
+ * @method static Planks CRIMSON_PLANKS()
+ * @method static WoodenPressurePlate CRIMSON_PRESSURE_PLATE()
+ * @method static WoodenSlab CRIMSON_SLAB()
+ * @method static WoodenStairs CRIMSON_STAIRS()
+ * @method static Wood CRIMSON_STEM()
+ * @method static WoodenTrapdoor CRIMSON_TRAPDOOR()
  * @method static Opaque CUT_RED_SANDSTONE()
  * @method static Slab CUT_RED_SANDSTONE_SLAB()
  * @method static Opaque CUT_SANDSTONE()
@@ -397,6 +408,17 @@ use pocketmine\utils\CloningRegistryTrait;
  * @method static LitPumpkin LIT_PUMPKIN()
  * @method static Loom LOOM()
  * @method static Magma MAGMA()
+ * @method static WoodenButton MANGROVE_BUTTON()
+ * @method static WoodenDoor MANGROVE_DOOR()
+ * @method static WoodenFence MANGROVE_FENCE()
+ * @method static FenceGate MANGROVE_FENCE_GATE()
+ * @method static Wood MANGROVE_LOG()
+ * @method static Planks MANGROVE_PLANKS()
+ * @method static WoodenPressurePlate MANGROVE_PRESSURE_PLATE()
+ * @method static WoodenSlab MANGROVE_SLAB()
+ * @method static WoodenStairs MANGROVE_STAIRS()
+ * @method static WoodenTrapdoor MANGROVE_TRAPDOOR()
+ * @method static Wood MANGROVE_WOOD()
  * @method static ChemistryTable MATERIAL_REDUCER()
  * @method static Melon MELON()
  * @method static MelonStem MELON_STEM()
@@ -587,6 +609,17 @@ use pocketmine\utils\CloningRegistryTrait;
  * @method static Vine VINES()
  * @method static WallBanner WALL_BANNER()
  * @method static WallCoralFan WALL_CORAL_FAN()
+ * @method static WoodenButton WARPED_BUTTON()
+ * @method static WoodenDoor WARPED_DOOR()
+ * @method static WoodenFence WARPED_FENCE()
+ * @method static FenceGate WARPED_FENCE_GATE()
+ * @method static Wood WARPED_HYPHAE()
+ * @method static Planks WARPED_PLANKS()
+ * @method static WoodenPressurePlate WARPED_PRESSURE_PLATE()
+ * @method static WoodenSlab WARPED_SLAB()
+ * @method static WoodenStairs WARPED_STAIRS()
+ * @method static Wood WARPED_STEM()
+ * @method static WoodenTrapdoor WARPED_TRAPDOOR()
  * @method static Water WATER()
  * @method static WeightedPressurePlateHeavy WEIGHTED_PRESSURE_PLATE_HEAVY()
  * @method static WeightedPressurePlateLight WEIGHTED_PRESSURE_PLATE_LIGHT()
@@ -728,6 +761,17 @@ final class VanillaBlocks{
 		self::register("cracked_polished_blackstone_bricks", $factory->get(Ids::CRACKED_POLISHED_BLACKSTONE_BRICKS, 0));
 		self::register("cracked_stone_bricks", $factory->get(Ids::CRACKED_STONE_BRICKS, 0));
 		self::register("crafting_table", $factory->get(Ids::CRAFTING_TABLE, 0));
+		self::register("crimson_button", $factory->get(Ids::CRIMSON_BUTTON, 0));
+		self::register("crimson_door", $factory->get(Ids::CRIMSON_DOOR, 0));
+		self::register("crimson_fence", $factory->get(Ids::CRIMSON_FENCE, 0));
+		self::register("crimson_fence_gate", $factory->get(Ids::CRIMSON_FENCE_GATE, 0));
+		self::register("crimson_hyphae", $factory->get(Ids::CRIMSON_HYPHAE, 4));
+		self::register("crimson_planks", $factory->get(Ids::CRIMSON_PLANKS, 0));
+		self::register("crimson_pressure_plate", $factory->get(Ids::CRIMSON_PRESSURE_PLATE, 0));
+		self::register("crimson_slab", $factory->get(Ids::CRIMSON_SLAB, 0));
+		self::register("crimson_stairs", $factory->get(Ids::CRIMSON_STAIRS, 0));
+		self::register("crimson_stem", $factory->get(Ids::CRIMSON_STEM, 4));
+		self::register("crimson_trapdoor", $factory->get(Ids::CRIMSON_TRAPDOOR, 0));
 		self::register("cut_red_sandstone", $factory->get(Ids::CUT_RED_SANDSTONE, 0));
 		self::register("cut_red_sandstone_slab", $factory->get(Ids::CUT_RED_SANDSTONE_SLAB, 0));
 		self::register("cut_sandstone", $factory->get(Ids::CUT_SANDSTONE, 0));
@@ -982,6 +1026,17 @@ final class VanillaBlocks{
 		self::register("lit_pumpkin", $factory->get(Ids::LIT_PUMPKIN, 0));
 		self::register("loom", $factory->get(Ids::LOOM, 0));
 		self::register("magma", $factory->get(Ids::MAGMA, 0));
+		self::register("mangrove_button", $factory->get(Ids::MANGROVE_BUTTON, 0));
+		self::register("mangrove_door", $factory->get(Ids::MANGROVE_DOOR, 0));
+		self::register("mangrove_fence", $factory->get(Ids::MANGROVE_FENCE, 0));
+		self::register("mangrove_fence_gate", $factory->get(Ids::MANGROVE_FENCE_GATE, 0));
+		self::register("mangrove_log", $factory->get(Ids::MANGROVE_LOG, 4));
+		self::register("mangrove_planks", $factory->get(Ids::MANGROVE_PLANKS, 0));
+		self::register("mangrove_pressure_plate", $factory->get(Ids::MANGROVE_PRESSURE_PLATE, 0));
+		self::register("mangrove_slab", $factory->get(Ids::MANGROVE_SLAB, 0));
+		self::register("mangrove_stairs", $factory->get(Ids::MANGROVE_STAIRS, 0));
+		self::register("mangrove_trapdoor", $factory->get(Ids::MANGROVE_TRAPDOOR, 0));
+		self::register("mangrove_wood", $factory->get(Ids::MANGROVE_WOOD, 4));
 		self::register("material_reducer", $factory->get(Ids::MATERIAL_REDUCER, 0));
 		self::register("melon", $factory->get(Ids::MELON, 0));
 		self::register("melon_stem", $factory->get(Ids::MELON_STEM, 0));
@@ -1172,6 +1227,17 @@ final class VanillaBlocks{
 		self::register("vines", $factory->get(Ids::VINES, 0));
 		self::register("wall_banner", $factory->get(Ids::WALL_BANNER, 0));
 		self::register("wall_coral_fan", $factory->get(Ids::WALL_CORAL_FAN, 4));
+		self::register("warped_button", $factory->get(Ids::WARPED_BUTTON, 0));
+		self::register("warped_door", $factory->get(Ids::WARPED_DOOR, 0));
+		self::register("warped_fence", $factory->get(Ids::WARPED_FENCE, 0));
+		self::register("warped_fence_gate", $factory->get(Ids::WARPED_FENCE_GATE, 0));
+		self::register("warped_hyphae", $factory->get(Ids::WARPED_HYPHAE, 4));
+		self::register("warped_planks", $factory->get(Ids::WARPED_PLANKS, 0));
+		self::register("warped_pressure_plate", $factory->get(Ids::WARPED_PRESSURE_PLATE, 0));
+		self::register("warped_slab", $factory->get(Ids::WARPED_SLAB, 0));
+		self::register("warped_stairs", $factory->get(Ids::WARPED_STAIRS, 0));
+		self::register("warped_stem", $factory->get(Ids::WARPED_STEM, 4));
+		self::register("warped_trapdoor", $factory->get(Ids::WARPED_TRAPDOOR, 0));
 		self::register("water", $factory->get(Ids::WATER, 0));
 		self::register("weighted_pressure_plate_heavy", $factory->get(Ids::WEIGHTED_PRESSURE_PLATE_HEAVY, 0));
 		self::register("weighted_pressure_plate_light", $factory->get(Ids::WEIGHTED_PRESSURE_PLATE_LIGHT, 0));
diff --git a/src/block/Wood.php b/src/block/Wood.php
index 3202dfa0d..46bb4afa6 100644
--- a/src/block/Wood.php
+++ b/src/block/Wood.php
@@ -24,7 +24,7 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\block\utils\PillarRotationTrait;
-use pocketmine\block\utils\TreeType;
+use pocketmine\block\utils\WoodTypeTrait;
 use pocketmine\data\runtime\block\BlockDataReader;
 use pocketmine\data\runtime\block\BlockDataWriter;
 use pocketmine\item\Axe;
@@ -34,16 +34,10 @@ use pocketmine\player\Player;
 
 class Wood extends Opaque{
 	use PillarRotationTrait;
-
-	private TreeType $treeType;
+	use WoodTypeTrait;
 
 	private bool $stripped = false;
 
-	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo, TreeType $treeType){
-		parent::__construct($idInfo, $name, $breakInfo);
-		$this->treeType = $treeType;
-	}
-
 	public function getRequiredTypeDataBits() : int{ return 1; }
 
 	protected function decodeType(BlockDataReader $r) : void{
@@ -54,13 +48,6 @@ class Wood extends Opaque{
 		$w->writeBool($this->stripped);
 	}
 
-	/**
-	 * TODO: this is ad hoc, but add an interface for this to all tree-related blocks
-	 */
-	public function getTreeType() : TreeType{
-		return $this->treeType;
-	}
-
 	public function isStripped() : bool{ return $this->stripped; }
 
 	/** @return $this */
@@ -74,11 +61,11 @@ class Wood extends Opaque{
 	}
 
 	public function getFlameEncouragement() : int{
-		return 5;
+		return $this->woodType->isFlammable() ? 5 : 0;
 	}
 
 	public function getFlammability() : int{
-		return 5;
+		return $this->woodType->isFlammable() ? 5 : 0;
 	}
 
 	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
diff --git a/src/block/WoodenButton.php b/src/block/WoodenButton.php
index 3116840b2..d1123ec2d 100644
--- a/src/block/WoodenButton.php
+++ b/src/block/WoodenButton.php
@@ -23,7 +23,10 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\WoodTypeTrait;
+
 class WoodenButton extends Button{
+	use WoodTypeTrait;
 
 	protected function getActivationTime() : int{
 		return 30;
diff --git a/src/block/WoodenDoor.php b/src/block/WoodenDoor.php
index c77253e69..e398812cd 100644
--- a/src/block/WoodenDoor.php
+++ b/src/block/WoodenDoor.php
@@ -23,6 +23,8 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-class WoodenDoor extends Door{
+use pocketmine\block\utils\WoodTypeTrait;
 
+class WoodenDoor extends Door{
+	use WoodTypeTrait;
 }
diff --git a/src/block/WoodenFence.php b/src/block/WoodenFence.php
index a84abef5f..88d444f51 100644
--- a/src/block/WoodenFence.php
+++ b/src/block/WoodenFence.php
@@ -23,17 +23,20 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\WoodTypeTrait;
+
 class WoodenFence extends Fence{
+	use WoodTypeTrait;
 
 	public function getFuelTime() : int{
 		return 300;
 	}
 
 	public function getFlameEncouragement() : int{
-		return 5;
+		return $this->woodType->isFlammable() ? 5 : 0;
 	}
 
 	public function getFlammability() : int{
-		return 20;
+		return $this->woodType->isFlammable() ? 20 : 0;
 	}
 }
diff --git a/src/block/WoodenPressurePlate.php b/src/block/WoodenPressurePlate.php
index 163789b2f..baaf44c2c 100644
--- a/src/block/WoodenPressurePlate.php
+++ b/src/block/WoodenPressurePlate.php
@@ -23,7 +23,10 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\WoodTypeTrait;
+
 class WoodenPressurePlate extends SimplePressurePlate{
+	use WoodTypeTrait;
 
 	public function getFuelTime() : int{
 		return 300;
diff --git a/src/block/WoodenSlab.php b/src/block/WoodenSlab.php
index f1fc42b66..b6f6647da 100644
--- a/src/block/WoodenSlab.php
+++ b/src/block/WoodenSlab.php
@@ -23,17 +23,20 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\WoodTypeTrait;
+
 class WoodenSlab extends Slab{
+	use WoodTypeTrait;
 
 	public function getFuelTime() : int{
 		return 300;
 	}
 
 	public function getFlameEncouragement() : int{
-		return 5;
+		return $this->woodType->isFlammable() ? 5 : 0;
 	}
 
 	public function getFlammability() : int{
-		return 20;
+		return $this->woodType->isFlammable() ? 20 : 0;
 	}
 }
diff --git a/src/block/WoodenStairs.php b/src/block/WoodenStairs.php
index 9c2f16a15..30fa7e602 100644
--- a/src/block/WoodenStairs.php
+++ b/src/block/WoodenStairs.php
@@ -23,7 +23,10 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\WoodTypeTrait;
+
 class WoodenStairs extends Stair{
+	use WoodTypeTrait;
 
 	public function getFlameEncouragement() : int{
 		return 5;
diff --git a/src/block/WoodenTrapdoor.php b/src/block/WoodenTrapdoor.php
index 83b3fb6c8..c0a6623a1 100644
--- a/src/block/WoodenTrapdoor.php
+++ b/src/block/WoodenTrapdoor.php
@@ -23,7 +23,10 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\WoodTypeTrait;
+
 class WoodenTrapdoor extends Trapdoor{
+	use WoodTypeTrait;
 
 	public function getFuelTime() : int{
 		return 300;
diff --git a/src/block/utils/WoodType.php b/src/block/utils/WoodType.php
new file mode 100644
index 000000000..e31f3a6da
--- /dev/null
+++ b/src/block/utils/WoodType.php
@@ -0,0 +1,82 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\block\utils;
+
+use pocketmine\utils\EnumTrait;
+
+/**
+ * This doc-block is generated automatically, do not modify it manually.
+ * This must be regenerated whenever registry members are added, removed or changed.
+ * @see build/generate-registry-annotations.php
+ * @generate-registry-docblock
+ *
+ * @method static WoodType ACACIA()
+ * @method static WoodType BIRCH()
+ * @method static WoodType CRIMSON()
+ * @method static WoodType DARK_OAK()
+ * @method static WoodType JUNGLE()
+ * @method static WoodType MANGROVE()
+ * @method static WoodType OAK()
+ * @method static WoodType SPRUCE()
+ * @method static WoodType WARPED()
+ */
+final class WoodType{
+	use EnumTrait {
+		__construct as private Enum___construct;
+	}
+
+	protected static function setup() : void{
+		self::registerAll(
+			new self("oak", "Oak", true),
+			new self("spruce", "Spruce", true),
+			new self("birch", "Birch", true),
+			new self("jungle", "Jungle", true),
+			new self("acacia", "Acacia", true),
+			new self("dark_oak", "Dark Oak", true),
+			new self("mangrove", "Mangrove", true),
+			new self("crimson", "Crimson", false, "Stem", "Hyphae"),
+			new self("warped", "Warped", false, "Stem", "Hyphae")
+		);
+	}
+
+	private function __construct(
+		string $enumName,
+		private string $displayName,
+		private bool $flammable,
+		private ?string $standardLogSuffix = null,
+		private ?string $allSidedLogSuffix = null,
+	){
+		$this->Enum___construct($enumName);
+	}
+
+	public function getDisplayName() : string{ return $this->displayName; }
+
+	public function isFlammable() : bool{ return $this->flammable; }
+
+	/** @return string|null */
+	public function getStandardLogSuffix() : ?string{ return $this->standardLogSuffix; }
+
+	/** @return string|null */
+	public function getAllSidedLogSuffix() : ?string{ return $this->allSidedLogSuffix; }
+}
diff --git a/src/block/utils/WoodTypeTrait.php b/src/block/utils/WoodTypeTrait.php
new file mode 100644
index 000000000..0ecd4e6f1
--- /dev/null
+++ b/src/block/utils/WoodTypeTrait.php
@@ -0,0 +1,40 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\block\utils;
+
+use pocketmine\block\BlockBreakInfo;
+use pocketmine\block\BlockIdentifier;
+
+trait WoodTypeTrait{
+	private WoodType $woodType; //immutable for now
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo, WoodType $woodType){
+		$this->woodType = $woodType;
+		parent::__construct($idInfo, $name, $breakInfo);
+	}
+
+	public function getWoodType() : WoodType{
+		return $this->woodType;
+	}
+}
diff --git a/src/data/bedrock/block/convert/BlockObjectToBlockStateSerializer.php b/src/data/bedrock/block/convert/BlockObjectToBlockStateSerializer.php
index b7329f989..ec5942cda 100644
--- a/src/data/bedrock/block/convert/BlockObjectToBlockStateSerializer.php
+++ b/src/data/bedrock/block/convert/BlockObjectToBlockStateSerializer.php
@@ -458,6 +458,17 @@ final class BlockObjectToBlockStateSerializer implements BlockStateSerializer{
 		$this->mapSimple(Blocks::CRACKED_POLISHED_BLACKSTONE_BRICKS(), Ids::CRACKED_POLISHED_BLACKSTONE_BRICKS);
 		$this->map(Blocks::CRACKED_STONE_BRICKS(), fn() => Helper::encodeStoneBricks(StringValues::STONE_BRICK_TYPE_CRACKED));
 		$this->mapSimple(Blocks::CRAFTING_TABLE(), Ids::CRAFTING_TABLE);
+		$this->map(Blocks::CRIMSON_BUTTON(), fn(Button $block) => Helper::encodeButton($block, new Writer(Ids::CRIMSON_BUTTON)));
+		$this->map(Blocks::CRIMSON_DOOR(), fn(Door $block) => Helper::encodeDoor($block, new Writer(Ids::CRIMSON_DOOR)));
+		$this->mapSimple(Blocks::CRIMSON_FENCE(), Ids::CRIMSON_FENCE);
+		$this->map(Blocks::CRIMSON_FENCE_GATE(), fn(FenceGate $block) => Helper::encodeFenceGate($block, new Writer(Ids::CRIMSON_FENCE_GATE)));
+		$this->map(Blocks::CRIMSON_HYPHAE(), fn(Wood $block) => Helper::encodeNewLog($block, Ids::CRIMSON_HYPHAE, Ids::STRIPPED_CRIMSON_HYPHAE));
+		$this->mapSimple(Blocks::CRIMSON_PLANKS(), Ids::CRIMSON_PLANKS);
+		$this->map(Blocks::CRIMSON_PRESSURE_PLATE(), fn(SimplePressurePlate $block) => Helper::encodeSimplePressurePlate($block, new Writer(Ids::CRIMSON_PRESSURE_PLATE)));
+		$this->mapSlab(Blocks::CRIMSON_SLAB(), Ids::CRIMSON_SLAB, Ids::CRIMSON_DOUBLE_SLAB);
+		$this->mapStairs(Blocks::CRIMSON_STAIRS(), Ids::CRIMSON_STAIRS);
+		$this->map(Blocks::CRIMSON_STEM(), fn(Wood $block) => Helper::encodeNewLog($block, Ids::CRIMSON_STEM, Ids::STRIPPED_CRIMSON_STEM));
+		$this->map(Blocks::CRIMSON_TRAPDOOR(), fn(Trapdoor $block) => Helper::encodeTrapdoor($block, new Writer(Ids::CRIMSON_TRAPDOOR)));
 		$this->map(Blocks::CUT_RED_SANDSTONE(), fn() => Helper::encodeSandstone(Ids::RED_SANDSTONE, StringValues::SAND_STONE_TYPE_CUT));
 		$this->map(Blocks::CUT_RED_SANDSTONE_SLAB(), fn(Slab $block) => Helper::encodeStoneSlab4($block, StringValues::STONE_SLAB_TYPE_4_CUT_RED_SANDSTONE));
 		$this->map(Blocks::CUT_SANDSTONE(), fn() => Helper::encodeSandstone(Ids::SANDSTONE, StringValues::SAND_STONE_TYPE_CUT));
@@ -829,6 +840,27 @@ final class BlockObjectToBlockStateSerializer implements BlockStateSerializer{
 				->writeLegacyHorizontalFacing($block->getFacing());
 		});
 		$this->mapSimple(Blocks::MAGMA(), Ids::MAGMA);
+		$this->map(Blocks::MANGROVE_BUTTON(), fn(Button $block) => Helper::encodeButton($block, new Writer(Ids::MANGROVE_BUTTON)));
+		$this->map(Blocks::MANGROVE_DOOR(), fn(Door $block) => Helper::encodeDoor($block, new Writer(Ids::MANGROVE_DOOR)));
+		$this->mapSimple(Blocks::MANGROVE_FENCE(), Ids::MANGROVE_FENCE);
+		$this->map(Blocks::MANGROVE_FENCE_GATE(), fn(FenceGate $block) => Helper::encodeFenceGate($block, new Writer(Ids::MANGROVE_FENCE_GATE)));
+		$this->map(Blocks::MANGROVE_LOG(), fn(Wood $block) => Helper::encodeNewLog($block, Ids::MANGROVE_LOG, Ids::STRIPPED_MANGROVE_LOG));
+		$this->mapSimple(Blocks::MANGROVE_PLANKS(), Ids::MANGROVE_PLANKS);
+		$this->map(Blocks::MANGROVE_PRESSURE_PLATE(), fn(SimplePressurePlate $block) => Helper::encodeSimplePressurePlate($block, new Writer(Ids::MANGROVE_PRESSURE_PLATE)));
+		$this->mapSlab(Blocks::MANGROVE_SLAB(), Ids::MANGROVE_SLAB, Ids::MANGROVE_DOUBLE_SLAB);
+		$this->mapStairs(Blocks::MANGROVE_STAIRS(), Ids::MANGROVE_STAIRS);
+		$this->map(Blocks::MANGROVE_TRAPDOOR(), fn(Trapdoor $block) => Helper::encodeTrapdoor($block, new Writer(Ids::MANGROVE_TRAPDOOR)));
+		$this->map(Blocks::MANGROVE_WOOD(), function(Wood $block) : Writer{
+			//we can't use the standard method for this because mangrove_wood has a useless property attached to it
+			if(!$block->isStripped()){
+				return Writer::create(Ids::MANGROVE_WOOD)
+					->writePillarAxis($block->getAxis())
+					->writeBool(StateNames::STRIPPED_BIT, false); //this is useless, but it has to be written
+			}else{
+				return Writer::create(Ids::STRIPPED_MANGROVE_WOOD)
+					->writePillarAxis($block->getAxis());
+			}
+		});
 		$this->map(Blocks::MATERIAL_REDUCER(), fn(ChemistryTable $block) => Helper::encodeChemistryTable($block, StringValues::CHEMISTRY_TABLE_TYPE_MATERIAL_REDUCER, new Writer(Ids::CHEMISTRY_TABLE)));
 		$this->mapSimple(Blocks::MELON(), Ids::MELON_BLOCK);
 		$this->map(Blocks::MELON_STEM(), fn(MelonStem $block) => Helper::encodeStem($block, new Writer(Ids::MELON_STEM)));
@@ -1152,6 +1184,17 @@ final class BlockObjectToBlockStateSerializer implements BlockStateSerializer{
 				->writeBool(StateNames::DEAD_BIT, $block->isDead())
 				->writeCoralFacing($block->getFacing());
 		});
+		$this->map(Blocks::WARPED_BUTTON(), fn(Button $block) => Helper::encodeButton($block, new Writer(Ids::WARPED_BUTTON)));
+		$this->map(Blocks::WARPED_DOOR(), fn(Door $block) => Helper::encodeDoor($block, new Writer(Ids::WARPED_DOOR)));
+		$this->mapSimple(Blocks::WARPED_FENCE(), Ids::WARPED_FENCE);
+		$this->map(Blocks::WARPED_FENCE_GATE(), fn(FenceGate $block) => Helper::encodeFenceGate($block, new Writer(Ids::WARPED_FENCE_GATE)));
+		$this->map(Blocks::WARPED_HYPHAE(), fn(Wood $block) => Helper::encodeNewLog($block, Ids::WARPED_HYPHAE, Ids::STRIPPED_WARPED_HYPHAE));
+		$this->mapSimple(Blocks::WARPED_PLANKS(), Ids::WARPED_PLANKS);
+		$this->map(Blocks::WARPED_PRESSURE_PLATE(), fn(SimplePressurePlate $block) => Helper::encodeSimplePressurePlate($block, new Writer(Ids::WARPED_PRESSURE_PLATE)));
+		$this->mapSlab(Blocks::WARPED_SLAB(), Ids::WARPED_SLAB, Ids::WARPED_DOUBLE_SLAB);
+		$this->mapStairs(Blocks::WARPED_STAIRS(), Ids::WARPED_STAIRS);
+		$this->map(Blocks::WARPED_STEM(), fn(Wood $block) => Helper::encodeNewLog($block, Ids::WARPED_STEM, Ids::STRIPPED_WARPED_STEM));
+		$this->map(Blocks::WARPED_TRAPDOOR(), fn(Trapdoor $block) => Helper::encodeTrapdoor($block, new Writer(Ids::WARPED_TRAPDOOR)));
 		$this->map(Blocks::WATER(), fn(Water $block) => Helper::encodeLiquid($block, Ids::WATER, Ids::FLOWING_WATER));
 		$this->map(Blocks::WEIGHTED_PRESSURE_PLATE_HEAVY(), function(WeightedPressurePlateHeavy $block) : Writer{
 			return Writer::create(Ids::HEAVY_WEIGHTED_PRESSURE_PLATE)
diff --git a/src/data/bedrock/block/convert/BlockStateSerializerHelper.php b/src/data/bedrock/block/convert/BlockStateSerializerHelper.php
index 56fe6ab08..9ef70b361 100644
--- a/src/data/bedrock/block/convert/BlockStateSerializerHelper.php
+++ b/src/data/bedrock/block/convert/BlockStateSerializerHelper.php
@@ -56,7 +56,7 @@ final class BlockStateSerializerHelper{
 		return BlockStateWriter::create(Ids::WOOD)
 			->writeBool(BlockStateNames::STRIPPED_BIT, $block->isStripped())
 			->writePillarAxis($block->getAxis())
-			->writeTreeType($block->getTreeType());
+			->writeLegacyWoodType($block->getWoodType());
 	}
 
 	public static function encodeButton(Button $block, BlockStateWriter $out) : BlockStateWriter{
@@ -151,6 +151,13 @@ final class BlockStateSerializerHelper{
 		);
 	}
 
+	public static function encodeNewLog(Wood $block, string $unstrippedId, string $strippedId) : BlockStateWriter{
+		return self::encodeLog($block, $block->isStripped() ?
+			BlockStateWriter::create($strippedId) :
+			BlockStateWriter::create($unstrippedId)
+		);
+	}
+
 	public static function encodeMushroomBlock(RedMushroomBlock $block, BlockStateWriter $out) : BlockStateWriter{
 		return $out
 			->writeInt(BlockStateNames::HUGE_MUSHROOM_BITS, MushroomBlockTypeIdMap::getInstance()->toId($block->getMushroomBlockType()));
diff --git a/src/data/bedrock/block/convert/BlockStateToBlockObjectDeserializer.php b/src/data/bedrock/block/convert/BlockStateToBlockObjectDeserializer.php
index f2309ee47..1dbdf8a32 100644
--- a/src/data/bedrock/block/convert/BlockStateToBlockObjectDeserializer.php
+++ b/src/data/bedrock/block/convert/BlockStateToBlockObjectDeserializer.php
@@ -300,6 +300,17 @@ final class BlockStateToBlockObjectDeserializer implements BlockStateDeserialize
 		$this->map(Ids::CRACKED_NETHER_BRICKS, fn() => Blocks::CRACKED_NETHER_BRICKS());
 		$this->map(Ids::CRACKED_POLISHED_BLACKSTONE_BRICKS, fn() => Blocks::CRACKED_POLISHED_BLACKSTONE_BRICKS());
 		$this->map(Ids::CRAFTING_TABLE, fn() => Blocks::CRAFTING_TABLE());
+		$this->map(Ids::CRIMSON_BUTTON, fn(Reader $in) => Helper::decodeButton(Blocks::CRIMSON_BUTTON(), $in));
+		$this->map(Ids::CRIMSON_DOOR, fn(Reader $in) => Helper::decodeDoor(Blocks::CRIMSON_DOOR(), $in));
+		$this->mapSlab(Ids::CRIMSON_SLAB, Ids::CRIMSON_DOUBLE_SLAB, fn() => Blocks::CRIMSON_SLAB());
+		$this->map(Ids::CRIMSON_FENCE, fn() => Blocks::CRIMSON_FENCE());
+		$this->map(Ids::CRIMSON_FENCE_GATE, fn(Reader $in) => Helper::decodeFenceGate(Blocks::CRIMSON_FENCE_GATE(), $in));
+		$this->map(Ids::CRIMSON_HYPHAE, fn(Reader $in) => Helper::decodeLog(Blocks::CRIMSON_HYPHAE(), false, $in));
+		$this->map(Ids::CRIMSON_PLANKS, fn() => Blocks::CRIMSON_PLANKS());
+		$this->map(Ids::CRIMSON_PRESSURE_PLATE, fn(Reader $in) => Helper::decodeSimplePressurePlate(Blocks::CRIMSON_PRESSURE_PLATE(), $in));
+		$this->mapStairs(Ids::CRIMSON_STAIRS, fn() => Blocks::CRIMSON_STAIRS());
+		$this->map(Ids::CRIMSON_STEM, fn(Reader $in) => Helper::decodeLog(Blocks::CRIMSON_STEM(), false, $in));
+		$this->map(Ids::CRIMSON_TRAPDOOR, fn(Reader $in) => Helper::decodeTrapdoor(Blocks::CRIMSON_TRAPDOOR(), $in));
 		$this->map(Ids::CYAN_GLAZED_TERRACOTTA, fn(Reader $in) => Helper::decodeGlazedTerracotta(DyeColor::CYAN(), $in));
 		$this->map(Ids::DARK_OAK_BUTTON, fn(Reader $in) => Helper::decodeButton(Blocks::DARK_OAK_BUTTON(), $in));
 		$this->map(Ids::DARK_OAK_DOOR, fn(Reader $in) => Helper::decodeDoor(Blocks::DARK_OAK_DOOR(), $in));
@@ -715,6 +726,20 @@ final class BlockStateToBlockObjectDeserializer implements BlockStateDeserialize
 		});
 		$this->map(Ids::MAGENTA_GLAZED_TERRACOTTA, fn(Reader $in) => Helper::decodeGlazedTerracotta(DyeColor::MAGENTA(), $in));
 		$this->map(Ids::MAGMA, fn() => Blocks::MAGMA());
+		$this->map(Ids::MANGROVE_BUTTON, fn(Reader $in) => Helper::decodeButton(Blocks::MANGROVE_BUTTON(), $in));
+		$this->map(Ids::MANGROVE_DOOR, fn(Reader $in) => Helper::decodeDoor(Blocks::MANGROVE_DOOR(), $in));
+		$this->mapSlab(Ids::MANGROVE_SLAB, Ids::MANGROVE_DOUBLE_SLAB, fn() => Blocks::MANGROVE_SLAB());
+		$this->map(Ids::MANGROVE_FENCE, fn() => Blocks::MANGROVE_FENCE());
+		$this->map(Ids::MANGROVE_FENCE_GATE, fn(Reader $in) => Helper::decodeFenceGate(Blocks::MANGROVE_FENCE_GATE(), $in));
+		$this->map(Ids::MANGROVE_LOG, fn(Reader $in) => Helper::decodeLog(Blocks::MANGROVE_LOG(), false, $in));
+		$this->map(Ids::MANGROVE_PLANKS, fn() => Blocks::MANGROVE_PLANKS());
+		$this->map(Ids::MANGROVE_PRESSURE_PLATE, fn(Reader $in) => Helper::decodeSimplePressurePlate(Blocks::MANGROVE_PRESSURE_PLATE(), $in));
+		$this->mapStairs(Ids::MANGROVE_STAIRS, fn() => Blocks::MANGROVE_STAIRS());
+		$this->map(Ids::MANGROVE_TRAPDOOR, fn(Reader $in) => Helper::decodeTrapdoor(Blocks::MANGROVE_TRAPDOOR(), $in));
+		$this->map(Ids::MANGROVE_WOOD, function(Reader $in){
+			$in->ignored(StateNames::STRIPPED_BIT); //this is also ignored by vanilla
+			return Helper::decodeLog(Blocks::MANGROVE_WOOD(), false, $in);
+		});
 		$this->map(Ids::MELON_BLOCK, fn() => Blocks::MELON());
 		$this->map(Ids::MELON_STEM, fn(Reader $in) => Helper::decodeStem(Blocks::MELON_STEM(), $in));
 		$this->map(Ids::MOB_SPAWNER, fn() => Blocks::MONSTER_SPAWNER());
@@ -1037,10 +1062,16 @@ final class BlockStateToBlockObjectDeserializer implements BlockStateDeserialize
 		});
 		$this->map(Ids::STRIPPED_ACACIA_LOG, fn(Reader $in) => Helper::decodeLog(Blocks::ACACIA_LOG(), true, $in));
 		$this->map(Ids::STRIPPED_BIRCH_LOG, fn(Reader $in) => Helper::decodeLog(Blocks::BIRCH_LOG(), true, $in));
+		$this->map(Ids::STRIPPED_CRIMSON_HYPHAE, fn(Reader $in) => Helper::decodeLog(Blocks::CRIMSON_HYPHAE(), true, $in));
+		$this->map(Ids::STRIPPED_CRIMSON_STEM, fn(Reader $in) => Helper::decodeLog(Blocks::CRIMSON_STEM(), true, $in));
 		$this->map(Ids::STRIPPED_DARK_OAK_LOG, fn(Reader $in) => Helper::decodeLog(Blocks::DARK_OAK_LOG(), true, $in));
 		$this->map(Ids::STRIPPED_JUNGLE_LOG, fn(Reader $in) => Helper::decodeLog(Blocks::JUNGLE_LOG(), true, $in));
+		$this->map(Ids::STRIPPED_MANGROVE_LOG, fn(Reader $in) => Helper::decodeLog(Blocks::MANGROVE_LOG(), true, $in));
+		$this->map(Ids::STRIPPED_MANGROVE_WOOD, fn(Reader $in) => Helper::decodeLog(Blocks::MANGROVE_WOOD(), true, $in));
 		$this->map(Ids::STRIPPED_OAK_LOG, fn(Reader $in) => Helper::decodeLog(Blocks::OAK_LOG(), true, $in));
 		$this->map(Ids::STRIPPED_SPRUCE_LOG, fn(Reader $in) => Helper::decodeLog(Blocks::SPRUCE_LOG(), true, $in));
+		$this->map(Ids::STRIPPED_WARPED_HYPHAE, fn(Reader $in) => Helper::decodeLog(Blocks::WARPED_HYPHAE(), true, $in));
+		$this->map(Ids::STRIPPED_WARPED_STEM, fn(Reader $in) => Helper::decodeLog(Blocks::WARPED_STEM(), true, $in));
 		$this->map(Ids::SWEET_BERRY_BUSH, function(Reader $in) : Block{
 			//berry bush only wants 0-3, but it can be bigger in MCPE due to misuse of GROWTH state which goes up to 7
 			$growth = $in->readBoundedInt(StateNames::GROWTH, 0, 7);
@@ -1107,6 +1138,17 @@ final class BlockStateToBlockObjectDeserializer implements BlockStateDeserialize
 				->setFacing($in->readHorizontalFacing());
 		});
 		$this->map(Ids::WALL_SIGN, fn(Reader $in) => Helper::decodeWallSign(Blocks::OAK_WALL_SIGN(), $in));
+		$this->map(Ids::WARPED_BUTTON, fn(Reader $in) => Helper::decodeButton(Blocks::WARPED_BUTTON(), $in));
+		$this->map(Ids::WARPED_DOOR, fn(Reader $in) => Helper::decodeDoor(Blocks::WARPED_DOOR(), $in));
+		$this->mapSlab(Ids::WARPED_SLAB, Ids::WARPED_DOUBLE_SLAB, fn() => Blocks::WARPED_SLAB());
+		$this->map(Ids::WARPED_FENCE, fn() => Blocks::WARPED_FENCE());
+		$this->map(Ids::WARPED_FENCE_GATE, fn(Reader $in) => Helper::decodeFenceGate(Blocks::WARPED_FENCE_GATE(), $in));
+		$this->map(Ids::WARPED_HYPHAE, fn(Reader $in) => Helper::decodeLog(Blocks::WARPED_HYPHAE(), false, $in));
+		$this->map(Ids::WARPED_PLANKS, fn() => Blocks::WARPED_PLANKS());
+		$this->map(Ids::WARPED_PRESSURE_PLATE, fn(Reader $in) => Helper::decodeSimplePressurePlate(Blocks::WARPED_PRESSURE_PLATE(), $in));
+		$this->mapStairs(Ids::WARPED_STAIRS, fn() => Blocks::WARPED_STAIRS());
+		$this->map(Ids::WARPED_STEM, fn(Reader $in) => Helper::decodeLog(Blocks::WARPED_STEM(), false, $in));
+		$this->map(Ids::WARPED_TRAPDOOR, fn(Reader $in) => Helper::decodeTrapdoor(Blocks::WARPED_TRAPDOOR(), $in));
 		$this->map(Ids::WATER, fn(Reader $in) => Helper::decodeStillLiquid(Blocks::WATER(), $in));
 		$this->map(Ids::WATERLILY, fn() => Blocks::LILY_PAD());
 		$this->map(Ids::WEB, fn() => Blocks::COBWEB());
diff --git a/src/data/bedrock/block/convert/BlockStateWriter.php b/src/data/bedrock/block/convert/BlockStateWriter.php
index 4186972dd..285a52aa1 100644
--- a/src/data/bedrock/block/convert/BlockStateWriter.php
+++ b/src/data/bedrock/block/convert/BlockStateWriter.php
@@ -27,8 +27,8 @@ use pocketmine\block\utils\BellAttachmentType;
 use pocketmine\block\utils\CoralType;
 use pocketmine\block\utils\DyeColor;
 use pocketmine\block\utils\SlabType;
-use pocketmine\block\utils\TreeType;
 use pocketmine\block\utils\WallConnectionType;
+use pocketmine\block\utils\WoodType;
 use pocketmine\data\bedrock\block\BlockStateData;
 use pocketmine\data\bedrock\block\BlockStateNames;
 use pocketmine\data\bedrock\block\BlockStateSerializeException;
@@ -226,15 +226,15 @@ final class BlockStateWriter{
 	}
 
 	/** @return $this */
-	public function writeTreeType(TreeType $treeType) : self{
+	public function writeLegacyWoodType(WoodType $treeType) : self{
 		$this->writeString(BlockStateNames::WOOD_TYPE, match($treeType->id()){
-			TreeType::OAK()->id() => StringValues::WOOD_TYPE_OAK,
-			TreeType::SPRUCE()->id() => StringValues::WOOD_TYPE_SPRUCE,
-			TreeType::BIRCH()->id() => StringValues::WOOD_TYPE_BIRCH,
-			TreeType::JUNGLE()->id() => StringValues::WOOD_TYPE_JUNGLE,
-			TreeType::ACACIA()->id() => StringValues::WOOD_TYPE_ACACIA,
-			TreeType::DARK_OAK()->id() => StringValues::WOOD_TYPE_DARK_OAK,
-			default => throw new BlockStateSerializeException("Invalid Tree type " . $treeType->name())
+			WoodType::OAK()->id() => StringValues::WOOD_TYPE_OAK,
+			WoodType::SPRUCE()->id() => StringValues::WOOD_TYPE_SPRUCE,
+			WoodType::BIRCH()->id() => StringValues::WOOD_TYPE_BIRCH,
+			WoodType::JUNGLE()->id() => StringValues::WOOD_TYPE_JUNGLE,
+			WoodType::ACACIA()->id() => StringValues::WOOD_TYPE_ACACIA,
+			WoodType::DARK_OAK()->id() => StringValues::WOOD_TYPE_DARK_OAK,
+			default => throw new BlockStateSerializeException("Invalid Wood type " . $treeType->name())
 		});
 		return $this;
 	}
diff --git a/src/data/bedrock/item/ItemDeserializer.php b/src/data/bedrock/item/ItemDeserializer.php
index 5008b3345..1fff31589 100644
--- a/src/data/bedrock/item/ItemDeserializer.php
+++ b/src/data/bedrock/item/ItemDeserializer.php
@@ -270,7 +270,7 @@ final class ItemDeserializer{
 		//TODO: minecraft:cow_spawn_egg
 		//TODO: minecraft:creeper_banner_pattern
 		//TODO: minecraft:creeper_spawn_egg
-		//TODO: minecraft:crimson_door
+		$this->map(Ids::CRIMSON_DOOR, fn() => Blocks::CRIMSON_DOOR()->asItem());
 		//TODO: minecraft:crimson_sign
 		//TODO: minecraft:crossbow
 		$this->map(Ids::CYAN_DYE, fn() => Items::DYE()->setColor(DyeColor::CYAN()));
@@ -421,6 +421,7 @@ final class ItemDeserializer{
 		$this->map(Ids::MAGENTA_DYE, fn() => Items::DYE()->setColor(DyeColor::MAGENTA()));
 		$this->map(Ids::MAGMA_CREAM, fn() => Items::MAGMA_CREAM());
 		//TODO: minecraft:magma_cube_spawn_egg
+		$this->map(Ids::MANGROVE_DOOR, fn() => Blocks::MANGROVE_DOOR()->asItem());
 		//TODO: minecraft:medicine
 		$this->map(Ids::MELON_SEEDS, fn() => Items::MELON_SEEDS());
 		$this->map(Ids::MELON_SLICE, fn() => Items::MELON());
@@ -592,7 +593,7 @@ final class ItemDeserializer{
 		$this->map(Ids::VILLAGER_SPAWN_EGG, fn() => Items::VILLAGER_SPAWN_EGG());
 		//TODO: minecraft:vindicator_spawn_egg
 		//TODO: minecraft:wandering_trader_spawn_egg
-		//TODO: minecraft:warped_door
+		$this->map(Ids::WARPED_DOOR, fn() => Blocks::WARPED_DOOR()->asItem());
 		//TODO: minecraft:warped_fungus_on_a_stick
 		//TODO: minecraft:warped_sign
 		$this->map(Ids::WATER_BUCKET, fn() => Items::WATER_BUCKET());
diff --git a/src/data/bedrock/item/ItemSerializer.php b/src/data/bedrock/item/ItemSerializer.php
index 47c84f6e7..e45c98f3f 100644
--- a/src/data/bedrock/item/ItemSerializer.php
+++ b/src/data/bedrock/item/ItemSerializer.php
@@ -228,18 +228,21 @@ final class ItemSerializer{
 		$this->mapBlock(Blocks::BIRCH_DOOR(), self::id(Ids::BIRCH_DOOR));
 		$this->mapBlock(Blocks::BREWING_STAND(), self::id(Ids::BREWING_STAND));
 		$this->mapBlock(Blocks::CAKE(), self::id(Ids::CAKE));
+		$this->mapBlock(Blocks::CRIMSON_DOOR(), self::id(Ids::CRIMSON_DOOR));
 		$this->mapBlock(Blocks::DARK_OAK_DOOR(), self::id(Ids::DARK_OAK_DOOR));
 		$this->mapBlock(Blocks::FLOWER_POT(), self::id(Ids::FLOWER_POT));
 		$this->mapBlock(Blocks::HOPPER(), self::id(Ids::HOPPER));
 		$this->mapBlock(Blocks::IRON_DOOR(), self::id(Ids::IRON_DOOR));
 		$this->mapBlock(Blocks::ITEM_FRAME(), self::id(Ids::FRAME));
 		$this->mapBlock(Blocks::JUNGLE_DOOR(), self::id(Ids::JUNGLE_DOOR));
+		$this->mapBlock(Blocks::MANGROVE_DOOR(), self::id(Ids::MANGROVE_DOOR));
 		$this->mapBlock(Blocks::NETHER_WART(), self::id(Ids::NETHER_WART));
 		$this->mapBlock(Blocks::OAK_DOOR(), self::id(Ids::WOODEN_DOOR));
 		$this->mapBlock(Blocks::REDSTONE_COMPARATOR(), self::id(Ids::COMPARATOR));
 		$this->mapBlock(Blocks::REDSTONE_REPEATER(), self::id(Ids::REPEATER));
 		$this->mapBlock(Blocks::SPRUCE_DOOR(), self::id(Ids::SPRUCE_DOOR));
 		$this->mapBlock(Blocks::SUGARCANE(), self::id(Ids::SUGAR_CANE));
+		$this->mapBlock(Blocks::WARPED_DOOR(), self::id(Ids::WARPED_DOOR));
 
 		$this->mapBlock(Blocks::BED(), fn(Bed $block) => new Data(Ids::BED, DyeColorIdMap::getInstance()->toId($block->getColor())));
 		$this->mapBlock(Blocks::MOB_HEAD(), fn(Skull $block) => new Data(Ids::SKULL, $block->getSkullType()->getMagicNumber()));
diff --git a/src/item/StringToItemParser.php b/src/item/StringToItemParser.php
index d8d54924e..97c9bbdb8 100644
--- a/src/item/StringToItemParser.php
+++ b/src/item/StringToItemParser.php
@@ -226,6 +226,17 @@ final class StringToItemParser extends StringToTParser{
 		$result->registerBlock("cracked_stone_bricks", fn() => Blocks::CRACKED_STONE_BRICKS());
 		$result->registerBlock("crafting_table", fn() => Blocks::CRAFTING_TABLE());
 		$result->registerBlock("creeper_head", fn() => Blocks::MOB_HEAD()->setSkullType(SkullType::CREEPER()));
+		$result->registerBlock("crimson_button", fn() => Blocks::CRIMSON_BUTTON());
+		$result->registerBlock("crimson_door", fn() => Blocks::CRIMSON_DOOR());
+		$result->registerBlock("crimson_fence", fn() => Blocks::CRIMSON_FENCE());
+		$result->registerBlock("crimson_fence_gate", fn() => Blocks::CRIMSON_FENCE_GATE());
+		$result->registerBlock("crimson_hyphae", fn() => Blocks::CRIMSON_HYPHAE()->setStripped(false));
+		$result->registerBlock("crimson_planks", fn() => Blocks::CRIMSON_PLANKS());
+		$result->registerBlock("crimson_pressure_plate", fn() => Blocks::CRIMSON_PRESSURE_PLATE());
+		$result->registerBlock("crimson_slab", fn() => Blocks::CRIMSON_SLAB());
+		$result->registerBlock("crimson_stairs", fn() => Blocks::CRIMSON_STAIRS());
+		$result->registerBlock("crimson_stem", fn() => Blocks::CRIMSON_STEM()->setStripped(false));
+		$result->registerBlock("crimson_trapdoor", fn() => Blocks::CRIMSON_TRAPDOOR());
 		$result->registerBlock("cut_red_sandstone", fn() => Blocks::CUT_RED_SANDSTONE());
 		$result->registerBlock("cut_red_sandstone_slab", fn() => Blocks::CUT_RED_SANDSTONE_SLAB());
 		$result->registerBlock("cut_sandstone", fn() => Blocks::CUT_SANDSTONE());
@@ -685,6 +696,17 @@ final class StringToItemParser extends StringToTParser{
 		$result->registerBlock("log2", fn() => Blocks::ACACIA_LOG()->setStripped(false));
 		$result->registerBlock("loom", fn() => Blocks::LOOM());
 		$result->registerBlock("magma", fn() => Blocks::MAGMA());
+		$result->registerBlock("mangrove_button", fn() => Blocks::MANGROVE_BUTTON());
+		$result->registerBlock("mangrove_door", fn() => Blocks::MANGROVE_DOOR());
+		$result->registerBlock("mangrove_fence", fn() => Blocks::MANGROVE_FENCE());
+		$result->registerBlock("mangrove_fence_gate", fn() => Blocks::MANGROVE_FENCE_GATE());
+		$result->registerBlock("mangrove_log", fn() => Blocks::MANGROVE_LOG()->setStripped(false));
+		$result->registerBlock("mangrove_planks", fn() => Blocks::MANGROVE_PLANKS());
+		$result->registerBlock("mangrove_pressure_plate", fn() => Blocks::MANGROVE_PRESSURE_PLATE());
+		$result->registerBlock("mangrove_slab", fn() => Blocks::MANGROVE_SLAB());
+		$result->registerBlock("mangrove_stairs", fn() => Blocks::MANGROVE_STAIRS());
+		$result->registerBlock("mangrove_trapdoor", fn() => Blocks::MANGROVE_TRAPDOOR());
+		$result->registerBlock("mangrove_wood", fn() => Blocks::MANGROVE_WOOD()->setStripped(false));
 		$result->registerBlock("material_reducer", fn() => Blocks::MATERIAL_REDUCER());
 		$result->registerBlock("melon_block", fn() => Blocks::MELON());
 		$result->registerBlock("melon_stem", fn() => Blocks::MELON_STEM());
@@ -929,14 +951,20 @@ final class StringToItemParser extends StringToTParser{
 		$result->registerBlock("stripped_acacia_wood", fn() => Blocks::ACACIA_WOOD()->setStripped(true));
 		$result->registerBlock("stripped_birch_log", fn() => Blocks::BIRCH_LOG()->setStripped(true));
 		$result->registerBlock("stripped_birch_wood", fn() => Blocks::BIRCH_WOOD()->setStripped(true));
+		$result->registerBlock("stripped_crimson_hyphae", fn() => Blocks::CRIMSON_HYPHAE()->setStripped(true));
+		$result->registerBlock("stripped_crimson_stem", fn() => Blocks::CRIMSON_STEM()->setStripped(true));
 		$result->registerBlock("stripped_dark_oak_log", fn() => Blocks::DARK_OAK_LOG()->setStripped(true));
 		$result->registerBlock("stripped_dark_oak_wood", fn() => Blocks::DARK_OAK_WOOD()->setStripped(true));
 		$result->registerBlock("stripped_jungle_log", fn() => Blocks::JUNGLE_LOG()->setStripped(true));
 		$result->registerBlock("stripped_jungle_wood", fn() => Blocks::JUNGLE_WOOD()->setStripped(true));
+		$result->registerBlock("stripped_mangrove_log", fn() => Blocks::MANGROVE_LOG()->setStripped(true));
+		$result->registerBlock("stripped_mangrove_wood", fn() => Blocks::MANGROVE_WOOD()->setStripped(true));
 		$result->registerBlock("stripped_oak_log", fn() => Blocks::OAK_LOG()->setStripped(true));
 		$result->registerBlock("stripped_oak_wood", fn() => Blocks::OAK_WOOD()->setStripped(true));
 		$result->registerBlock("stripped_spruce_log", fn() => Blocks::SPRUCE_LOG()->setStripped(true));
 		$result->registerBlock("stripped_spruce_wood", fn() => Blocks::SPRUCE_WOOD()->setStripped(true));
+		$result->registerBlock("stripped_warped_hyphae", fn() => Blocks::WARPED_HYPHAE()->setStripped(true));
+		$result->registerBlock("stripped_warped_stem", fn() => Blocks::WARPED_STEM()->setStripped(true));
 		$result->registerBlock("sugar_cane", fn() => Blocks::SUGARCANE());
 		$result->registerBlock("sugar_canes", fn() => Blocks::SUGARCANE());
 		$result->registerBlock("sugarcane", fn() => Blocks::SUGARCANE());
@@ -968,6 +996,17 @@ final class StringToItemParser extends StringToTParser{
 		$result->registerBlock("wall_banner", fn() => Blocks::WALL_BANNER());
 		$result->registerBlock("wall_coral_fan", fn() => Blocks::WALL_CORAL_FAN());
 		$result->registerBlock("wall_sign", fn() => Blocks::OAK_WALL_SIGN());
+		$result->registerBlock("warped_button", fn() => Blocks::WARPED_BUTTON());
+		$result->registerBlock("warped_door", fn() => Blocks::WARPED_DOOR());
+		$result->registerBlock("warped_fence", fn() => Blocks::WARPED_FENCE());
+		$result->registerBlock("warped_fence_gate", fn() => Blocks::WARPED_FENCE_GATE());
+		$result->registerBlock("warped_hyphae", fn() => Blocks::WARPED_HYPHAE()->setStripped(false));
+		$result->registerBlock("warped_planks", fn() => Blocks::WARPED_PLANKS());
+		$result->registerBlock("warped_pressure_plate", fn() => Blocks::WARPED_PRESSURE_PLATE());
+		$result->registerBlock("warped_slab", fn() => Blocks::WARPED_SLAB());
+		$result->registerBlock("warped_stairs", fn() => Blocks::WARPED_STAIRS());
+		$result->registerBlock("warped_stem", fn() => Blocks::WARPED_STEM()->setStripped(false));
+		$result->registerBlock("warped_trapdoor", fn() => Blocks::WARPED_TRAPDOOR());
 		$result->registerBlock("water", fn() => Blocks::WATER());
 		$result->registerBlock("water_lily", fn() => Blocks::LILY_PAD());
 		$result->registerBlock("waterlily", fn() => Blocks::LILY_PAD());