mirror of
https://github.com/pmmp/PocketMine-MP.git
synced 2025-04-21 16:24:05 +00:00
Added various blocks made from mangrove, crimson and warped wood
This commit is contained in:
Dylan K. Taylor
parent
6176f0d9df
commit
dd615c775d
@ -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));
|
||||
|
||||
@ -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");
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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{
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -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));
|
||||
|
||||
@ -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{
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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;
|
||||
|
||||
82
src/block/utils/WoodType.php
Normal file
82
src/block/utils/WoodType.php
Normal file
@ -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; }
|
||||
}
|
||||
40
src/block/utils/WoodTypeTrait.php
Normal file
40
src/block/utils/WoodTypeTrait.php
Normal file
@ -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;
|
||||
}
|
||||
}
|
||||
@ -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)
|
||||
|
||||
@ -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()));
|
||||
|
||||
@ -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());
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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());
|
||||
|
||||
@ -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()));
|
||||
|
||||
@ -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());
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user