PocketMine-MP 5.33.2 git-09cc76ae2b49f1fe3ab0253e6e987fb82bd0a08f
Loading...
Searching...
No Matches
BlockStateSerializerHelper.php
1<?php
2
3/*
4 *
5 * ____ _ _ __ __ _ __ __ ____
6 * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \
7 * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
8 * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/
9 * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_|
10 *
11 * This program is free software: you can redistribute it and/or modify
12 * it under the terms of the GNU Lesser General Public License as published by
13 * the Free Software Foundation, either version 3 of the License, or
14 * (at your option) any later version.
15 *
16 * @author PocketMine Team
17 * @link http://www.pocketmine.net/
18 *
19 *
20 */
21
22declare(strict_types=1);
23
24namespace pocketmine\data\bedrock\block\convert;
25
46use pocketmine\block\utils\CopperOxidation;
47use pocketmine\block\utils\SlabType;
57
62 public static function encodeButton(Button $block, Writer $out) : Writer{
63 return $out
64 ->writeFacingDirection($block->getFacing())
65 ->writeBool(BlockStateNames::BUTTON_PRESSED_BIT, $block->isPressed());
66 }
67
68 public static function encodeCandle(Candle $block, Writer $out) : Writer{
69 return $out
70 ->writeBool(StateNames::LIT, $block->isLit())
71 ->writeInt(StateNames::CANDLES, $block->getCount() - 1);
72 }
73
74 public static function encodeChemistryTable(ChemistryTable $block, Writer $out) : Writer{
75 return $out
76 ->writeLegacyHorizontalFacing(Facing::opposite($block->getFacing()));
77 }
78
79 public static function encodeCrops(Crops $block, Writer $out) : Writer{
80 return $out->writeInt(BlockStateNames::GROWTH, $block->getAge());
81 }
82
86 public static function encodeTorch(Torch $block, Writer $out) : Writer{
87 return $out
88 ->writeTorchFacing($block->getFacing());
89 }
90
91 public static function encodeCauldron(string $liquid, int $fillLevel) : Writer{
92 return Writer::create(Ids::CAULDRON)
93 ->writeString(BlockStateNames::CAULDRON_LIQUID, $liquid)
94 ->writeInt(BlockStateNames::FILL_LEVEL, $fillLevel);
95 }
96
97 public static function selectCopperId(CopperOxidation $oxidation, string $noneId, string $exposedId, string $weatheredId, string $oxidizedId) : string{
98 return match($oxidation){
99 CopperOxidation::NONE => $noneId,
100 CopperOxidation::EXPOSED => $exposedId,
101 CopperOxidation::WEATHERED => $weatheredId,
102 CopperOxidation::OXIDIZED => $oxidizedId,
103 };
104 }
105
109 public static function encodeDoor(Door $block, Writer $out) : Writer{
110 return $out
111 ->writeBool(BlockStateNames::UPPER_BLOCK_BIT, $block->isTop())
112 //a door facing north is encoded as "east"
113 ->writeCardinalHorizontalFacing(Facing::rotateY($block->getFacing(), clockwise: true))
114 ->writeBool(BlockStateNames::DOOR_HINGE_BIT, $block->isHingeRight())
115 ->writeBool(BlockStateNames::OPEN_BIT, $block->isOpen());
116 }
117
118 public static function encodeDoublePlant(DoublePlant $block, Writer $out) : Writer{
119 return $out
120 ->writeBool(BlockStateNames::UPPER_BLOCK_BIT, $block->isTop());
121 }
122
126 public static function encodeFenceGate(FenceGate $block, Writer $out) : Writer{
127 return $out
128 ->writeCardinalHorizontalFacing($block->getFacing())
129 ->writeBool(BlockStateNames::IN_WALL_BIT, $block->isInWall())
130 ->writeBool(BlockStateNames::OPEN_BIT, $block->isOpen());
131 }
132
136 public static function encodeFloorSign(FloorSign $block, Writer $out) : Writer{
137 return $out
138 ->writeInt(BlockStateNames::GROUND_SIGN_DIRECTION, $block->getRotation());
139 }
140
141 public static function encodeFurnace(Furnace $block, string $unlitId, string $litId) : Writer{
142 return Writer::create($block->isLit() ? $litId : $unlitId)
143 ->writeCardinalHorizontalFacing($block->getFacing());
144 }
145
146 public static function encodeItemFrame(ItemFrame $block, string $id) : Writer{
147 return Writer::create($id)
148 ->writeBool(StateNames::ITEM_FRAME_MAP_BIT, $block->hasMap())
149 ->writeBool(StateNames::ITEM_FRAME_PHOTO_BIT, false)
150 ->writeFacingDirection($block->getFacing());
151 }
152
156 public static function encodeLeaves(Leaves $block, Writer $out) : Writer{
157 return $out
158 ->writeBool(BlockStateNames::PERSISTENT_BIT, $block->isNoDecay())
159 ->writeBool(BlockStateNames::UPDATE_BIT, $block->isCheckDecay());
160 }
161
162 public static function encodeLiquid(Liquid $block, string $stillId, string $flowingId) : Writer{
163 return Writer::create($block->isStill() ? $stillId : $flowingId)
164 ->writeInt(BlockStateNames::LIQUID_DEPTH, $block->getDecay() | ($block->isFalling() ? 0x8 : 0));
165 }
166
167 public static function encodeLog(Wood $block, string $unstrippedId, string $strippedId) : Writer{
168 $out = $block->isStripped() ?
169 Writer::create($strippedId) :
170 Writer::create($unstrippedId);
171 return $out
172 ->writePillarAxis($block->getAxis());
173 }
174
175 public static function encodeMushroomBlock(RedMushroomBlock $block, Writer $out) : Writer{
176 return $out
177 ->writeInt(BlockStateNames::HUGE_MUSHROOM_BITS, MushroomBlockTypeIdMap::getInstance()->toId($block->getMushroomBlockType()));
178 }
179
183 public static function encodeQuartz(int $axis, Writer $out) : Writer{
184 return $out
185 ->writePillarAxis($axis); //this isn't needed for all types, but we have to write it anyway
186 }
187
191 public static function encodeSapling(Sapling $block, Writer $out) : Writer{
192 return $out
193 ->writeBool(BlockStateNames::AGE_BIT, $block->isReady());
194 }
195
196 public static function encodeSimplePressurePlate(SimplePressurePlate $block, Writer $out) : Writer{
197 //TODO: not sure what the deal is here ... seems like a mojang bug / artifact of bad implementation?
198 //best to keep this separate from weighted plates anyway...
199 return $out
200 ->writeInt(BlockStateNames::REDSTONE_SIGNAL, $block->isPressed() ? 15 : 0);
201 }
202
203 private static function encodeSingleSlab(Slab $block, string $id) : Writer{
204 return Writer::create($id)
205 ->writeSlabPosition($block->getSlabType());
206 }
207
208 private static function encodeDoubleSlab(Slab $block, string $id) : Writer{
209 return Writer::create($id)
210 //this is (intentionally) also written for double slabs (as zero) to maintain bug parity with MCPE
211 ->writeSlabPosition(SlabType::BOTTOM);
212 }
213
214 public static function encodeSlab(Slab $block, string $singleId, string $doubleId) : Writer{
215 return $block->getSlabType() === SlabType::DOUBLE ?
216 self::encodeDoubleSlab($block, $doubleId) :
217 self::encodeSingleSlab($block, $singleId);
218 }
219
223 public static function encodeStairs(Stair $block, Writer $out) : Writer{
224 return $out
225 ->writeBool(BlockStateNames::UPSIDE_DOWN_BIT, $block->isUpsideDown())
226 ->writeWeirdoHorizontalFacing($block->getFacing());
227 }
228
229 public static function encodeStem(Stem $block, Writer $out) : Writer{
230 //In PM, we use Facing::UP to indicate that the stem is not attached to a pumpkin/melon, since this makes the
231 //most intuitive sense (the stem is pointing at the sky). However, Bedrock uses the DOWN state for this, which
232 //is absurd, and I refuse to make our API similarly absurd.
233 $facing = $block->getFacing();
234 return self::encodeCrops($block, $out)
235 ->writeFacingWithoutUp($facing === Facing::UP ? Facing::DOWN : $facing);
236 }
237
241 public static function encodeTrapdoor(Trapdoor $block, Writer $out) : Writer{
242 return $out
243 ->write5MinusHorizontalFacing($block->getFacing())
244 ->writeBool(BlockStateNames::UPSIDE_DOWN_BIT, $block->isTop())
245 ->writeBool(BlockStateNames::OPEN_BIT, $block->isOpen());
246 }
247
248 public static function encodeWall(Wall $block, Writer $out) : Writer{
249 return $out
250 ->writeBool(BlockStateNames::WALL_POST_BIT, $block->isPost())
251 ->writeWallConnectionType(BlockStateNames::WALL_CONNECTION_TYPE_EAST, $block->getConnection(Facing::EAST))
252 ->writeWallConnectionType(BlockStateNames::WALL_CONNECTION_TYPE_NORTH, $block->getConnection(Facing::NORTH))
253 ->writeWallConnectionType(BlockStateNames::WALL_CONNECTION_TYPE_SOUTH, $block->getConnection(Facing::SOUTH))
254 ->writeWallConnectionType(BlockStateNames::WALL_CONNECTION_TYPE_WEST, $block->getConnection(Facing::WEST));
255 }
256
260 public static function encodeWallSign(WallSign $block, Writer $out) : Writer{
261 return $out
262 ->writeHorizontalFacing($block->getFacing());
263 }
264}