Merge branch 'stable'

# Conflicts:
#	resources/vanilla

.gitignore

@@ -1,5 +1,6 @@
 players/*
 worlds/*
+world_conversion_backups/*
 plugin_data/*
 plugins/*
 bin*/*
@@ -10,6 +11,7 @@ crashdumps/*
 *.phar
 server.properties
 /pocketmine.yml
+/plugin_list.yml
 memory_dumps/*
 resource_packs/
 server.lock

.gitmodules

@@ -1,5 +1,5 @@
-[submodule "src/pocketmine/lang/locale"]
-	path = src/pocketmine/lang/locale
+[submodule "resources/locale"]
+	path = resources/locale
 	url = https://github.com/pmmp/PocketMine-Language.git
 [submodule "tests/preprocessor"]
 	path = build/preprocessor
@@ -7,6 +7,6 @@
 [submodule "tests/plugins/PocketMine-DevTools"]
 	path = tests/plugins/PocketMine-DevTools
 	url = https://github.com/pmmp/PocketMine-DevTools.git
-[submodule "src/pocketmine/resources/vanilla"]
-	path = src/pocketmine/resources/vanilla
+[submodule "resources/vanilla"]
+	path = resources/vanilla
 	url = https://github.com/pmmp/BedrockData.git

.travis.yml

@@ -1,3 +1,4 @@
+dist: xenial
 language: php
 
 php:
@@ -5,8 +6,26 @@ php:
  - 7.3
 
 before_script:
+ - LEVELDB_VERSION=f1463cb0b2486b0caf7d42ca3c7684545e875f04
+ - curl -fsSL "https://github.com/pmmp/leveldb-mcpe/archive/f1463cb0b2486b0caf7d42ca3c7684545e875f04.tar.gz" | tar -zx
+ - mv leveldb-mcpe-$LEVELDB_VERSION leveldb-mcpe
+ - cd leveldb-mcpe && make -j4 && mv out-shared/libleveldb.* . && cd ..
+ - git clone https://github.com/reeze/php-leveldb.git leveldb
+ - cd leveldb
+ - git checkout 9bcae79f71b81a5c3ea6f67e45ae9ae9fb2775a5
+ - phpize
+ - ./configure --with-leveldb=../leveldb-mcpe && make && make install
+ - cd ..
+ - git clone https://github.com/pmmp/ext-chunkutils2.git chunkutils
+ - cd chunkutils
+ - git checkout d8d762a597ac0da6f333f862096d6af0e6286b75
+ - phpize
+ - ./configure && make && make install
+ - cd ..
 # - pecl install channel://pecl.php.net/pthreads-3.1.6
  - echo | pecl install channel://pecl.php.net/yaml-2.0.4
+ - pecl install channel://pecl.php.net/crypto-0.3.1
+ - pecl install channel://pecl.php.net/ds-1.2.8
  - git clone https://github.com/pmmp/pthreads.git
  - cd pthreads
  - git checkout 6ca019c58b4fa09ee2ff490f2444e34bef0773d0
@@ -16,6 +35,8 @@ before_script:
  - make install
  - cd ..
  - echo "extension=pthreads.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini
+ - echo "extension=chunkutils2.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini
+ - echo "extension=leveldb.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini
  - composer install
 
 script:

changelogs/4.0-snapshot.md

@@ -0,0 +1,765 @@
+# 4.0.0-SNAPSHOT-1907XX (2019-07-XX)
+
+This major version features substantial changes throughout the core, including significant API changes, new world format support, performance improvements and a network revamp.
+
+## Core
+### General
+- A new "plugin greylist" feature has been introduced, which allows whitelisting or blacklisting plugins from loading.
+- The `/reload` command has been removed.
+- The `/effect` command no longer supports numeric IDs - it's now required to use names.
+- Remote console (RCON) has been removed. The [RconServer](https://github.com/pmmp/RconServer) plugin is provided as a substitute.
+- Spawn protection has been removed. The [BasicSpawnProtection](https://github.com/pmmp/BasicSpawnProtection) plugin is provided as a substitute.
+- CTRL+C signal handling has been removed. The [PcntlSignalHandler](https://github.com/pmmp/PcntlSignalHandler) plugin is provided as a substitute.
+- Player movement anti-cheat has been removed. Its corresponding `pocketmine.yml` setting `player.anti-cheat.allow-movement-cheats` has been removed.
+- The `pocketmine_chunkutils` PHP extension has been dropped.
+- New PHP extensions are required by this version:
+  - [ds](https://github.com/php-ds/ext-ds)
+  - [chunkutils2](https://github.com/pmmp/ext-chunkutils2)
+
+### World format support
+- Modern Minecraft Bedrock world formats are now supported.
+- Automatic conversion of deprecated world formats is now implemented.
+- The following world formats have been deprecated and will be **automatically converted on load to a new format**:
+  - `mcregion`
+  - `anvil`
+  - `pmanvil`
+- 256 build-height is now supported in all worlds (facilitated by automatic conversion).
+- Extended blocks are now supported (facilitated by automatic conversion).
+- Unsupported world formats no longer causes a crash, but a graceful shutdown instead.
+- World corruption no longer causes a crash.
+
+### Logger revamp
+- Many components now have a dedicated logger which automatically adds [prefixes] to their messages.
+- Main logger now includes milliseconds in timestamps.
+
+### Network
+This version features substantial changes to the network system, improving coherency, reliability and modularity.
+
+#### Minecraft Bedrock packet encryption
+- This fixes replay attacks where hackers steal and replay player logins.
+- A new setting has been added to `pocketmine.yml`: `network.enable-encryption` which is `true` by default.
+
+#### Packet receive error handling has been overhauled
+- Only `BadPacketException` is now caught during packet decode and handling. This requires that all decoding MUST perform proper data error checking.
+  - Throwing a `BadPacketException` from decoding will now cause players to be kicked with the message `Packet processing error`.
+  - The disconnect message includes a random hex ID to help server owners identify the problems reported by their players.
+- Throwing any other exception will now cause a server crash. `Internal server error` has been removed.
+- It is now illegal to send a clientbound packet to the server. Doing so will result in the client being kicked with the message `Unexpected non-serverbound packet`.
+
+#### New packet handler system
+- Packet handlers have been separated from NetworkSession into a dedicated packet handler structure.
+- A network session may have exactly 1 handler at a time, which is mutable and may be replaced at any time. This allows packet handling logic to be broken up into multiple stages:
+  - preventing undefined behaviour when sending wrong packets at the wrong time (they'll now be silently dropped)
+  - allowing the existence of ephemeral state-specific logic (for example stricter resource packs download checks)
+- Packet handlers are now almost entirely absent from `Player` and instead appear in their own dedicated units.
+- Almost all game logic that was previously locked up inside packet handlers in `Player` has been extracted into new API methods. See Player API changes for details.
+
+## API
+### General
+- Most places which previously allowed `callable` now only allow `\Closure`. This is because closures have more consistent behaviour and are more performant.
+- `void` and `?nullable` parameter and return types have been applied in many places.
+- Everything in the `pocketmine\metadata` namespace and related implementations have been removed.
+
+### Block
+- Blocks with IDs >= 256 are now supported.
+- Block state and variant metadata have been separated.
+  - Variant is considered an extension of ID and is immutable.
+  - `Block->setDamage()` has been removed. `Block->readStateFromData()` is now used for state deserialization.
+- Tile entities are now created and deleted automatically when `World->setBlock()` is used with a block that requires a tile entity.
+- Some tile entities' API has been exposed on their corresponding `Block` classes, with the tile entity classes being deprecated.
+- The `pocketmine\tile` namespace has been relocated to `pocketmine\block\tile`.
+- `Block->recalculateBoundingBox()` and `Block->recalculateCollisionBoxes()` are now expected to return AABBs relative to `0,0,0` instead of their own position.
+- Block break-info has been extracted into a new dynamic `BlockBreakInfo` unit. The following methods have been moved:
+  - `Block->getBlastResistance()` -> `BlockBreakInfo->getBlastResistance()`
+  - `Block->getBreakTime()` -> `BlockBreakInfo->getBreakTime()`
+  - `Block->getHardness()` -> `BlockBreakInfo->getHardness()`
+  - `Block->getToolHarvestLevel()` -> `BlockBreakInfo->getToolHarvestLevel()`
+  - `Block->getToolType()` -> `BlockBreakInfo->getToolType()`
+  - `Block->isBreakable()` -> `BlockBreakInfo->isBreakable()`
+  - `Block->isCompatibleWithTool()` -> `BlockBreakInfo->isToolCompatible()`
+- The following API methods have been added:
+  - `Block->asItem()`: returns an itemstack corresponding to the block
+  - `Block->isSameState()`: returns whether the block is the same as the parameter, including state information
+  - `Block->isSameType()`: returns whether the block is the same as the parameter, without state information
+- The following hooks have been added:
+  - `Block->onAttack()`: called when a player in survival left-clicks the block to try to start breaking it
+  - `Block->onPostPlace()`: called directly after placement in the world, handles things like rail connections and chest pairing
+- The following API methods have been renamed:
+  - `Block->getDamage()` -> `Block->getMeta()`
+  - `Block->onActivate()` -> `Block->onInteract()`
+  - `Block->onEntityCollide()` -> `Block->onEntityInside()`
+- The following API methods have changed signatures:
+  - `Block->onInteract()` now has the signature `onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool`
+- The following API methods have been removed:
+  - `Block->canPassThrough()`
+  - `Block->setDamage()`
+  - `Block::get()`: this was superseded by `BlockFactory::get()` a long time ago
+- The following classes have been renamed:
+  - `BlockIds` -> `BlockLegacyIds`
+  - `CobblestoneWall` -> `Wall`
+  - `NoteBlock` -> `Note`
+  - `SignPost` -> `Sign`
+  - `StandingBanner` -> `Banner`
+- The following classes have been removed:
+  - `Bricks`
+  - `BurningFurnace`
+  - `CobblestoneStairs`
+  - `Dandelion`
+  - `DoubleSlab`
+  - `DoubleStoneSlab`
+  - `EndStone`
+  - `GlowingRedstoneOre`
+  - `GoldOre`
+  - `Gold`
+  - `IronDoor`
+  - `IronOre`
+  - `IronTrapdoor`
+  - `Iron`
+  - `Lapis`
+  - `NetherBrickFence`
+  - `NetherBrickStairs`
+  - `Obsidian`
+  - `PurpurStairs`
+  - `Purpur`
+  - `QuartzStairs`
+  - `Quartz`
+  - `RedSandstoneStairs`
+  - `RedSandstone`
+  - `SandstoneStairs`
+  - `Sandstone`
+  - `StainedClay`
+  - `StainedGlassPane`
+  - `StainedGlass`
+  - `StoneBrickStairs`
+  - `StoneBricks`
+  - `StoneSlab2`
+  - `StoneSlab`
+  - `Stone`
+  - `WallBanner`
+  - `WallSign`
+  - `Wood2`
+- `BlockToolType` constants have been renamed to remove the `TYPE_` prefix.
+
+### Command
+- The following classes have been removed:
+  - `RemoteConsoleCommandSender`
+- The following API methods have signature changes:
+  - `Command->setPermission()` argument is now mandatory (but still nullable).
+  - `CommandSender->setScreenLineHeight()` argument is now mandatory (but still nullable).
+
+### Entity
+#### General
+- The following API methods have been added:
+  - `ItemEntity->getDespawnDelay()`
+  - `ItemEntity->setDespawnDelay()`
+  - `Human->getHungerManager()`
+  - `Human->getXpManager()`
+- The following methods have signature changes:
+  - `Entity->entityBaseTick()` is now `protected`.
+  - `Entity->move()` is now `protected`.
+  - `Living->knockBack()` now accepts `float, float, float` (the first two parameters have been removed).
+  - `Living->getEffects()` now returns `EffectManager` instead of `Effect[]`.
+- The following classes have been added:
+  - `effect\EffectManager`: contains effect-management functionality extracted from `Living`
+  - `HungerManager`: contains hunger-management functionality extracted from `Human`
+  - `ExperienceManager`: contains XP-management functionality extracted from `Human`
+- The following API methods have been moved / renamed:
+  - `Living->removeAllEffects()` -> `EffectManager->clear()`
+  - `Living->removeEffect()` -> `EffectManager->remove()`
+  - `Living->addEffect()` -> `EffectManager->add()`
+  - `Living->getEffect()` -> `EffectManager->get()`
+  - `Living->hasEffect()` -> `EffectManager->has()`
+  - `Living->hasEffects()` -> `EffectManager->hasEffects()`
+  - `Living->getEffects()` -> `EffectManager->all()`
+  - `Human->getFood()` -> `HungerManager->getFood()`
+  - `Human->setFood()` -> `HungerManager->setFood()`
+  - `Human->getMaxFood()` -> `HungerManager->getMaxFood()`
+  - `Human->addFood()` -> `HungerManager->addFood()`
+  - `Human->isHungry()` -> `HungerManager->isHungry()`
+  - `Human->getSaturation()` -> `HungerManager->getSaturation()`
+  - `Human->setSaturation()` -> `HungerManager->setSaturation()`
+  - `Human->addSaturation()` -> `HungerManager->addSaturation()`
+  - `Human->getExhaustion()` -> `HungerManager->getExhaustion()`
+  - `Human->setExhaustion()` -> `HungerManager->setExhaustion()`
+  - `Human->exhaust()` -> `HungerManager->exhaust()`
+  - `Human->getXpLevel()` -> `ExperienceManager->getXpLevel()`
+  - `Human->setXpLevel()` -> `ExperienceManager->setXpLevel()`
+  - `Human->addXpLevels()` -> `ExperienceManager->addXpLevels()`
+  - `Human->subtractXpLevels()` -> `ExperienceManager->subtractXpLevels()`
+  - `Human->getXpProgress()` -> `ExperienceManager->getXpProgress()`
+  - `Human->setXpProgress()` -> `ExperienceManager->setXpProgress()`
+  - `Human->getRemainderXp()` -> `ExperienceManager->getRemainderXp()`
+  - `Human->getCurrentTotalXp()` -> `ExperienceManager->getCurrentTotalXp()`
+  - `Human->setCurrentTotalXp()` -> `ExperienceManager->setCurrentTotalXp()`
+  - `Human->addXp()` -> `ExperienceManager->addXp()`
+  - `Human->subtractXp()` -> `ExperienceManager->subtractXp()`
+  - `Human->getLifetimeTotalXp()` -> `ExperienceManager->getLifetimeTotalXp()`
+  - `Human->setLifetimeTotalXp()` -> `ExperienceManager->setLifetimeTotalXp()`
+  - `Human->canPickupXp()` -> `ExperienceManager->canPickupXp()`
+  - `Human->onPickupXp()` -> `ExperienceManager->onPickupXp()`
+  - `Human->resetXpCooldown()` -> `ExperienceManager->resetXpCooldown()`
+- The following API methods have been removed:
+  - `Human->getRawUniqueId()`: use `Human->getUniqueId()->toBinary()` instead
+- The following classes have been removed:
+  - `Creature`
+  - `Damageable`
+  - `Monster`
+  - `NPC`
+  - `Rideable`
+  - `Vehicle`
+- `Skin` now throws exceptions on creation if given invalid data.
+
+#### Effect
+- All `Effect` related classes have been moved to the `pocketmine\entity\effect` namespace.
+- Effect functionality embedded in the `Effect` class has been separated out into several classes. The following classes have been added:
+  - `AbsorptionEffect`
+  - `HealthBoostEffect`
+  - `HungerEffect`
+  - `InstantDamageEffect`
+  - `InstantEffect`
+  - `InstantHealthEffect`
+  - `InvisibilityEffect`
+  - `LevitationEffect`
+  - `PoisonEffect`
+  - `RegenerationEffect`
+  - `SaturationEffect`
+  - `SlownessEffect`
+  - `SpeedEffect`
+  - `WitherEffect`
+- Negative effect amplifiers are now explicitly disallowed due to undefined behaviour they created.
+- The following API methods have been renamed:
+  - `Effect::registerEffect()` -> `Effect::register()`
+  - `Effect::getEffect()` -> `Effect::get()`
+  - `Effect::getEffectByName()` -> `Effect::fromString()`
+- Static getter methods for all registered enchantment types have been added. `Effect::getEffect(Effect::WHATEVER)` should be replaced by `VanillaEffects::WHATEVER()`.
+- All effect registry functionality has been removed from the `Effect` base class and migrated to the `VanillaEffects` class.
+
+#### Removal of runtime entity NBT
+- Entities no longer keep their NBT alive at runtime.
+  - `Entity->namedtag` has been removed.
+  - `Entity->saveNBT()` now returns a newly created `CompoundTag` instead of modifying the previous one in-place.
+  - `Entity->initEntity()` now accepts a `CompoundTag` parameter.
+
+#### Entity creation
+- Entity class overriding is now explicitly supported, without needing to touch save IDs.
+  - Entity classes can be overridden using `EntityFactory::override()`. The provided replacement class **must** be a subclass of the existing class. If the existing class isn't there, an exception will be thrown.
+  - Attempting to register an entity to a save ID that is already registered will now cause an exception to be thrown.
+- Registering entities will now throw exceptions on error cases instead of returning `false`.
+- Entity creation has now been split into two paths:
+  - `EntityFactory::create()`: Creates an entity by the given class. This accepts arguments to be passed to the entity constructor. This function is guaranteed to return an entity which is an instanceof the given class.
+  - `EntityFactory::createFromData()`: Creates an entity from save data. This may return any `Entity` class or `NULL`. This function is internal and shouldn't be used by plugins.
+- It is no longer possible to directly create an entity by save ID. This is discouraged because save IDs are internal and format-dependent.
+- The following API methods have been moved:
+  - `Entity::registerEntity()` -> `EntityFactory::register()`
+  - `Entity::createEntity()` -> `EntityFactory::create()`
+  - `Entity::getKnownEntityTypes()` -> `EntityFactory::getKnownTypes()`
+  - `Entity::createBaseNBT()` -> `EntityFactory::createBaseNBT()`
+- The following API methods have been removed:
+  - `Entity->getSaveId()`
+
+#### WIP removal of entity network metadata
+- All network metadata related constants have been removed from the `Entity` class and moved to the protocol layer. It is intended to remove network metadata from the API entirely, but this has not yet been completed.
+  - `Entity::DATA_FLAG_*` constants have been moved to `pocketmine\network\mcpe\protocol\types\EntityMetadataFlags`.
+  - `Entity::DATA_TYPE_*` constants have been moved to `pocketmine\network\mcpe\protocol\types\EntityMetadataTypes`.
+  - `Entity::DATA_*` constants have been moved to `pocketmine\network\mcpe\protocol\types\EntityMetadataProperties`.
+- `DataPropertyManager` has been moved to the `pocketmine\network\mcpe\protocol\types` namespace, and as such isn't considered part of the API anymore.
+
+### Event
+#### Internal event system no longer depends on `Listener`s
+- The internal event processing system no longer depends on `Listener` objects. Arbitrary closures can now be used, provided that they satisfy the standard requirements to be a handler.
+  - This change improves performance of event handler calling by approximately 15%. This does not include anything plugins are doing.
+  - The following classes have been removed:
+    - `pocketmine\plugin\EventExecutor`
+    - `pocketmine\plugin\MethodEventExecutor`
+  - `RegisteredListener->__construct()` now requires `Closure` instead of `Listener, EventExecutor` as the leading parameters.
+  - `RegisteredListener->getListener()` has been removed.
+
+#### Default cancelled handling behaviour has changed
+- Handler functions will now **not receive cancelled events by default**. This is a **silent BC break**, i.e. it won't raise errors, but it might cause bugs.
+- `@ignoreCancelled` is now no longer respected.
+- `@handleCancelled` has been added. This allows opting _into_ receiving cancelled events (it's the opposite of `@ignoreCancelled`).
+
+#### `PlayerPreLoginEvent` changes
+- The `Player` object no longer exists at this phase of the login. Instead, a `PlayerInfo` object is provided, along with connection information.
+- Ban, server-full and whitelist checks are now centralized to `PlayerPreLoginEvent`. It's no longer necessary (or possible) to intercept `PlayerKickEvent` to handle these types of disconnects.
+  - Multiple kick reasons may be set to ensure that the player is still removed if there are other reasons for them to be disconnected and one of them is cleared. For example, if a player is banned and the server is full, clearing the ban flag will still cause the player to be disconnected because the server is full.
+  - Plugins may set custom kick reasons. Any custom reason has absolute priority.
+  - If multiple flags are set, the kick message corresponding to the highest priority reason will be shown. The priority (as of this snapshot) is as follows:
+    - Custom (highest priority)
+    - Server full
+    - Whitelisted
+    - Banned
+  - The `PlayerPreLoginEvent::KICK_REASON_PRIORITY` constant contains a list of kick reason priorities, highest first.
+- The following constants have been added:
+  - `PlayerPreLoginEvent::KICK_REASON_PLUGIN`
+  - `PlayerPreLoginEvent::KICK_REASON_SERVER_FULL`
+  - `PlayerPreLoginEvent::KICK_REASON_SERVER_WHITELISTED`
+  - `PlayerPreLoginEvent::KICK_REASON_BANNED`
+  - `PlayerPreLoginEvent::KICK_REASON_PRIORITY`: ordered list of kick reason priorities, highest first
+- The following API methods have been added:
+  - `PlayerPreLoginEvent->clearAllKickReasons()`
+  - `PlayerPreLoginEvent->clearKickReason()`
+  - `PlayerPreLoginEvent->getFinalKickMessage()`: the message to be shown to the player with the current reason list in place
+  - `PlayerPreLoginEvent->getIp()`
+  - `PlayerPreLoginEvent->getKickReasons()`: returns an array of flags indicating kick reasons, must be empty to allow joining
+  - `PlayerPreLoginEvent->getPlayerInfo()`
+  - `PlayerPreLoginEvent->getPort()`
+  - `PlayerPreLoginEvent->isAllowed()`
+  - `PlayerPreLoginEvent->isAuthRequired()`: whether XBL authentication will be enforced
+  - `PlayerPreLoginEvent->isKickReasonSet()`
+  - `PlayerPreLoginEvent->setAuthRequired()`
+  - `PlayerPreLoginEvent->setKickReason()`
+- The following API methods have been changed:
+  - `PlayerPreLoginEvent->getKickMessage()` now has the signature `getKickMessage(int $flag) : ?string`
+- The following API methods have been removed:
+  - `PlayerPreLoginEvent->setKickMessage()`
+  - `PlayerPreLoginEvent->getPlayer()`
+
+#### Other changes
+- Disconnecting players during events no longer crashes the server (although it might cause other side effects).
+- `PlayerKickEvent` is no longer fired for disconnects that occur before the player completes the initial login sequence (i.e. completing downloading resource packs).
+- Cancellable events must now implement `CancellableTrait` to get the cancellable components needed to satisfy interface requirements.
+- `PlayerInteractEvent` is no longer fired when a player activates an item. This fixes the age-old complaint of `PlayerInteractEvent` firing multiple times when interacting once. The following constants have been removed:
+  - `PlayerInteractEvent::LEFT_CLICK_AIR`
+  - `PlayerInteractEvent::RIGHT_CLICK_AIR`
+  - `PlayerInteractEvent::PHYSICAL`
+- The following events have been added:
+  - `PlayerItemUseEvent`: player activating their held item, for example to throw it.
+  - `BlockTeleportEvent`: block teleporting, for example dragon egg when attacked.
+- The following events have been removed:
+  - `EntityArmorChangeEvent`
+  - `EntityInventoryChangeEvent`
+  - `EntityLevelChangeEvent` - `EntityTeleportEvent` with world checks should be used instead.
+  - `NetworkInterfaceCrashEvent`
+  - `PlayerCheatEvent`
+  - `PlayerIllegalMoveEvent`
+- The following API methods have been added:
+  - `EntityDeathEvent->getXpDropAmount()`
+  - `EntityDeathEvent->setXpDropAmount()`
+  - `PlayerDeathEvent->getXpDropAmount()`
+  - `PlayerDeathEvent->setXpDropAmount()`
+- The following API methods have been removed:
+  - `PlayerPreLoginEvent->getPlayer()`
+- The following API methods have been moved:
+  - `Event->isCancelled()` -> `CancellableTrait->isCancelled()`: this was a stub which threw `BadMethodCallException` if the class didn't implement `Cancellable`; now this is simply not available on non-cancellable events
+  - `Event->setCancelled()` -> `CancellableTrait->setCancelled()`
+  - `HandlerList::unregisterAll()` -> `HandlerListManager->unregisterAll()`
+  - `HandlerList::getHandlerListFor()` -> `HandlerListManager->getListFor()`
+  - `HandlerList::getHandlerLists()` -> `HandlerListManager->getAll()`
+- The following classes have been moved:
+  - `pocketmine\plugin\RegisteredListener` -> `pocketmine\event\RegisteredListener`
+
+### Inventory
+- All crafting and recipe related classes have been moved to the `pocketmine\crafting` namespace.
+- The following classes have been added:
+  - `CallbackInventoryChangeListener`
+  - `CreativeInventory`: contains the creative functionality previously embedded in `pocketmine\item\Item`, see Item changes for details
+  - `InventoryChangeListener`: allows listening (but not interfering with) events in an inventory.
+  - `transaction\CreateItemAction`
+  - `transaction\DestroyItemAction`
+- The following classes have been renamed:
+  - `ContainerInventory` -> `BlockInventory`
+- The following classes have been removed:
+  - `CustomInventory`
+  - `InventoryEventProcessor`
+  - `Recipe`
+  - `transaction\CreativeInventoryAction`
+- The following API methods have been added:
+  - `Inventory->addChangeListeners()`
+  - `Inventory->getChangeListeners()`
+  - `Inventory->removeChangeListeners()`
+  - `Inventory->swap()`: swaps the contents of two slots
+- The following API methods have been removed:
+  - `BaseInventory->getDefaultSize()`
+  - `BaseInventory->setSize()`
+  - `Inventory->close()`
+  - `Inventory->dropContents()`
+  - `Inventory->getName()`
+  - `Inventory->getTitle()`
+  - `Inventory->onSlotChange()`
+  - `Inventory->open()`
+  - `Inventory->sendContents()`
+  - `Inventory->sendSlot()`
+  - `InventoryAction->onExecuteFail()`
+  - `InventoryAction->onExecuteSuccess()`
+  - `PlayerInventory->sendCreativeContents()`
+- The following API methods have signature changes:
+  - `Inventory->clear()` now returns `void` instead of `bool`.
+  - `Inventory->setItem()` now returns `void` instead of `bool`.
+  - `InventoryAction->execute()` now returns `void` instead of `bool`.
+  - `BaseInventory->construct()` no longer accepts a list of items to initialize with.
+- `PlayerInventory->setItemInHand()` now sends the update to viewers of the player.
+
+### Item
+#### General
+- `Item->count` is no longer public.
+- The hierarchy of writable books has been changed: `WritableBook` and `WrittenBook` now extend `WritableBookBase`.
+- The following API methods have signature changes:
+  - `WritableBookBase->setPages()` now accepts `WritableBookPage[]` instead of `CompoundTag[]`.
+  - `ItemFactory::get()` no longer accepts `string` for the `tags` parameter.
+  - `ItemFactory::fromString()` no longer accepts a `$multiple` parameter and now only returns `Item`, not `Item|Item[]`.
+- The following methods are now fluent:
+  - `WritableBookBase->setPages()`
+  - `Item->addEnchantment()`
+  - `Item->removeEnchantment()`
+  - `Item->removeEnchantments()`
+  - `Armor->setCustomColor()`
+  - `WrittenBook->setTitle()`
+  - `WrittenBook->setAuthor()`
+  - `WrittenBook->setGeneration()`
+- The following API methods have been removed:
+  - `Item->getNamedTagEntry()`
+  - `Item->removeNamedTagEntry()`
+  - `Item->setDamage()`: "Damage" is now immutable for all items except `Durable` descendents.
+  - `Item->setNamedTagEntry()`
+  - `Item::get()`: this was superseded by `ItemFactory::get()` a long time ago
+  - `Item::fromString()`: this was superseded by `ItemFactory::fromString()` a long time ago
+  - `Item->setCompoundTag()`
+  - `Item->getCompoundTag()`
+  - `Item->hasCompoundTag()`
+  - `ProjectileItem->getProjectileEntityType()`
+- The following methods have been renamed:
+  - `Item->getDamage()` -> `Item->getMeta()`
+- The following methods have been moved to `pocketmine\inventory\CreativeInventory`:
+  - `Item::addCreativeItem()` -> `CreativeInventory::add()`
+  - `Item::clearCreativeItems()` -> `CreativeInventory::clear()`
+  - `Item::getCreativeItemIndex()` -> `CreativeInventory::getItemIndex()`
+  - `Item::getCreativeItems()` -> `CreativeInventory::getAll()`
+  - `Item::initCreativeItems()` -> `CreativeInventory::init()`
+  - `Item::isCreativeItem()` -> `CreativeInventory::contains()`
+  - `Item::removeCreativeItem()` -> `CreativeInventory::remove()`
+- The following classes have been added:
+  - `ArmorTypeInfo`
+  - `Boots`
+  - `Chestplate`
+  - `Fertilizer`
+  - `Helmet`
+  - `Leggings`
+  - `LiquidBucket`
+  - `MilkBucket`
+  - `WritableBookBase`
+  - `WritableBookPage`
+- The following API methods have been added:
+  - `Armor->getArmorSlot()`
+  - `ProjectileItem->getProjectileEntityClass()`: returns the class of projectile to be created when thrown
+- The following classes have been removed:
+  - `ChainBoots`
+  - `ChainChestplate`
+  - `ChainHelmet`
+  - `ChainLeggings`
+  - `DiamondBoots`
+  - `DiamondChestplate`
+  - `DiamondHelmet`
+  - `DiamondLeggings`
+  - `GoldBoots`
+  - `GoldChestplate`
+  - `GoldHelmet`
+  - `GoldLeggings`
+  - `IronBoots`
+  - `IronChesplate`
+  - `IronHelmet`
+  - `IronLeggings`
+  - `LeatherBoots`
+  - `LeatherCap`
+  - `LeatherPants`
+  - `LeatherTunic`
+
+#### NBT handling
+- Serialized NBT byte array caches are no longer stored on itemstacks. These caches were a premature optimization used for network layer serialization and as such were dependent on the network NBT format.
+- Internal NBT usage has been marginalized. It's no longer necessary to immediately write changes to NBT. The following hooks have been added:
+  - `Item->serializeCompoundTag()`
+  - `Item->deserializeCompoundTag()`
+- It's planned to remove runtime NBT from items completely, but this currently presents unresolved backwards-compatibility problems.
+
+#### Enchantment
+- The following API methods have been renamed:
+  - `Enchantment::registerEnchantment()` -> `Enchantment::register()`
+  - `Enchantment::getEnchantment()` -> `Enchantment::get()`
+  - `Enchantment::getEnchantmentByName()` -> `Enchantment::fromString()`
+- Static getter methods for all registered enchantment types have been added. `Enchantment::getEnchantment(Enchantment::WHATEVER)` should be replaced by `Enchantment::WHATEVER()`.
+
+### Lang
+- The following classes have been renamed:
+  - `BaseLang` -> `Language`
+- `LanguageNotFoundException` has been added. This is thrown when trying to construct a `Language` which doesn't exist in the server files.
+
+
+### Network
+- The following fields have been removed:
+  - `Network::$BATCH_THRESHOLD`
+- The following classes have been renamed:
+  - `SourceInterface` -> `NetworkInterface`
+  - `AdvancedSourceInterface` -> `AdvancedNetworkInterface`
+- The following classes have been moved:
+  - `CompressBatchedTask` -> `mcpe\CompressBatchTask`
+  - `level\format\io\ChunkRequestTask` -> `mcpe\ChunkRequestTask`
+  - `mcpe\RakLibInterface` -> `mcpe\raklib\RakLibInterface`
+- The following classes have been removed:
+  - `mcpe\PlayerNetworkSessionAdapter`
+- The following methods have been removed:
+  - `NetworkInterface->putPacket()`
+  - `NetworkInterface->close()`
+  - `NetworkInterface->emergencyShutdown()`
+- `NetworkInterface` now represents a more generic interface to be implemented by any network component, as opposed to specifically a player network interface.
+- Everything under the `rcon` subnamespace has been removed.
+- `upnp\UPnP` has significant changes. It's now a network component instead of a pair of static methods.
+
+### Permission
+- Added `PermissibleDelegateTrait` to reduce boilerplate for users of `PermissibleBase`. This trait is used by `ConsoleCommandSender` and `Player`.
+- The following API methods have been moved:
+  - `Permission::getByName()` -> `PermissionParser::defaultFromString()`
+  - `Permission::loadPermissions()` -> `PermissionParser::loadPermissions()`
+  - `Permission::loadPermission()` -> `PermissionParser::loadPermission()`
+- The following API methods have been added:
+  - `PermissionParser::emitPermissions()`
+- The following API methods have changes:
+  - `PermissionParser::defaultFromString()` now throws `InvalidArgumentException` on unknown values.
+
+### Player
+- The following classes have moved to the new `pocketmine\player` namespace:
+  - `Achievement`
+  - `GameMode`
+  - `IPlayer`
+  - `OfflinePlayer`
+  - `PlayerInfo`
+  - `Player`
+- The following constants have been removed:
+  - `Player::SURVIVAL` - use `GameMode::SURVIVAL()`
+  - `Player::CREATIVE` - use `GameMode::CREATIVE()`
+  - `Player::ADVENTURE` - use `GameMode::ADVENTURE()`
+  - `Player::SPECTATOR` - use `GameMode::SPECTATOR()`
+  - `Player::VIEW` - use `GameMode::SPECTATOR()`
+- (almost) all packet handlers have been removed from `Player`. They are now encapsulated within the network layer.
+- The following API methods have been added:
+  - `Player->attackBlock()`: attack (left click) the target block, e.g. to start destroying it (survival)
+  - `Player->attackEntity()`: melee-attack (left click) the target entity (if within range)
+  - `Player->breakBlock()`: destroy the target block in the current world (immediately)
+  - `Player->consumeHeldItem()`: consume the previously activated item, e.g. eating food
+  - `Player->continueBreakBlock()`: punch the target block during destruction in survival, advancing break animation and creating particles
+  - `Player->hasFiniteResources()`
+  - `Player->interactBlock()`: interact (right click) the target block in the current world
+  - `Player->interactEntity()`: interact (right click) the target entity, e.g. to apply a nametag (not implemented yet)
+  - `Player->pickBlock()`: picks (mousewheel click) the target block in the current world
+  - `Player->releaseHeldItem()`: release the previously activated item, e.g. shooting a bow
+  - `Player->selectHotbarSlot()`: select the specified hotbar slot
+  - `Player->stopBreakBlock()`: cease attacking a previously attacked block
+  - `Player->toggleFlight()`: tries to start / stop flying (fires events, may be cancelled)
+  - `Player->updateNextPosition()`: sets the player's next attempted move location (fires events, may be cancelled)
+  - `Player->useHeldItem()`: activate the held item, e.g. throwing a snowball
+- The following API methods have been removed:
+  - `Player->addActionBarMessage()`: replaced by `sendActionBarMessage()`
+  - `Player->addSubTitle()`: replaced by `sendSubTitle()`
+  - `Player->addTitle()`: replaced by `sendTitle()`
+  - `Player->getAddress()`: replaced by `NetworkSession->getIp()`
+  - `Player->getPing()`: moved to `NetworkSession`
+  - `Player->getPort()`: moved to `NetworkSession`
+  - `Player->updatePing()`: moved to `NetworkSession`
+
+
+### Plugin
+- API version checks are now more strict. It is no longer legal to declare multiple minimum versions on the same major version. Doing so will now cause the plugin to fail to load with the message `Multiple minimum API versions found for some major versions`.
+- `plugin.yml` YAML commands loading is now internalized inside `PluginBase`.
+- `PluginManager->registerEvent()` now has a simpler signature: `registerEvent(string $event, \Closure $handler, int $priority, Plugin $plugin, bool $handleCancelled = false)`. The provided closure must accept the specified event class as its only parameter. See [Event API changes](#event) for more details.
+- The following classes have been removed:
+  - `PluginLogger`
+- The following interface requirements have been removed:
+  - `Plugin->onEnable()`: this is now internalized inside `PluginBase`
+  - `Plugin->onDisable()`: same as above
+  - `Plugin->onLoad()`: same as above
+  - `Plugin` no longer extends `CommandExecutor`. This means that `Plugin` implementations don't need to implement `onCommand()` anymore.
+- The following hook methods have changed visibility:
+  - `PluginBase->onEnable()` changed from `public` to `protected`
+  - `PluginBase->onDisable()` changed from `public` to `protected`
+  - `PluginBase->onLoad()` changed from `public` to `protected`
+- The following hook methods have been renamed:
+  - `Plugin->setEnabled()` -> `Plugin->onEnableStateChange()`. This change was made to force plugin developers misusing this hook to stop, and to give it a name that better describes what it does.
+- The following (deprecated) API methods have been removed:
+  - `PluginManager->callEvent()`: use `Event->call()` instead
+  - `PluginManager->addPermission()`: use `PermissionManager` instead
+  - `PluginManager->getDefaultPermSubscriptions()`: use `PermissionManager` instead
+  - `PluginManager->getDefaultPermissions()`: use `PermissionManager` instead
+  - `PluginManager->getPermission()`: use `PermissionManager` instead
+  - `PluginManager->getPermissionSubscriptions()`: use `PermissionManager` instead
+  - `PluginManager->getPermissions()`: use `PermissionManager` instead
+  - `PluginManager->recalculatePermissionDefaults()`: use `PermissionManager` instead
+  - `PluginManager->removePermission()`: use `PermissionManager` instead
+  - `PluginManager->subscribeToDefaultPerms()`: use `PermissionManager` instead
+  - `PluginManager->subscribeToPermission()`: use `PermissionManager` instead
+  - `PluginManager->unsubscribeFromDefaultPerms()`: use `PermissionManager` instead
+  - `PluginManager->unsubscribeFromPermission()`: use `PermissionManager` instead
+- It is no longer permitted to throw exceptions from `PluginBase->onEnable()` or `PluginBase->onLoad()`. Doing so will now cause the server to crash.
+
+### Scheduler
+#### Thread-local storage for AsyncTasks
+- TLS has been completely rewritten in this release to be self contained, more robust and easier to use.
+- Now behaves more like simple properties. `storeLocal()` writes, `fetchLocal()` reads.
+- Self-contained and doesn't depend on the async pool to clean up after it.
+- Values are automatically removed from storage when the `AsyncTask` is garbage-collected, just like a regular property.
+- Supports storing multiple values, differentiated by string names.
+- `fetchLocal()` can now be used multiple times. It no longer deletes the stored value.
+- The following classes have been removed:
+  - `FileWriteTask`
+- The following methods have been removed:
+  - `AsyncTask->peekLocal()`: use `fetchLocal()` instead
+- The following methods have signature changes:
+  - `AsyncTask->storeLocal()` now has the signature `storeLocal(string $key, mixed $complexData) : void`
+  - `AsyncTask->fetchLocal()` now has the signature `fetchLocal(string $key) : mixed`
+
+#### Other changes
+- `AsyncPool` uses a new, significantly more performant algorithm for task collection.
+- `BulkCurlTask` has had the `$complexData` constructor parameter removed.
+- `pocketmine\Collectable` has been removed, and is no longer extended by `AsyncTask`.
+- The following hooks have been added:
+  - `AsyncTask->onError()`: called on the main thread when an uncontrolled error was detected in the async task, such as a memory failure
+- The following hooks have signature changes:
+  - `AsyncTask->onCompletion()` no longer accepts a `Server` parameter, and has a `void` return type.
+  - `AsyncTask->onProgressUpdate()` no longer accepts a `Server` parameter, and has a `void` return type.
+- The following API methods have been removed:
+  - `AsyncTask->getFromThreadStore()`: use `AsyncTask->worker->getFromThreadStore()`
+  - `AsyncTask->removeFromThreadStore()`: use `AsyncTask->worker->removeFromThreadStore()`
+  - `AsyncTask->saveToThreadStore()`: use `AsyncTask->worker->saveToThreadStore()`
+
+### Server
+- The following API methods have been removed:
+  - `reloadWhitelist()`
+  - `getLevelMetadata()`
+  - `getPlayerMetadata()`
+  - `getEntityMetadata()`
+  - `getDefaultGamemode()`
+  - `getLoggedInPlayers()`
+  - `onPlayerLogout()`
+  - `addPlayer()`
+  - `removePlayer()`
+  - `reload()`
+  - `getSpawnRadius()`
+  - `enablePlugin()`
+  - `disablePlugin()`
+  - `getGamemodeString()` - replaced by `pocketmine\player\GameMode->getTranslationKey()`
+  - `getGamemodeName()` - replaced by `pocketmine\player\GameMode->name()`
+  - `getGamemodeFromString()` - replaced by `GameMode::fromString()`
+- The following API methods have changed:
+  - `getOfflinePlayerData()` no longer creates data when it doesn't exist.
+
+### Level / World
+#### General
+- All references to `Level` in the context of "world" have been changed to `World`.
+  - The `pocketmine\level` namespace has been renamed to `pocketmine\world`
+  - All classes containing the world `Level` in the name in the "world" context have been changed to `World`.
+  - `Position->getLevel()` has been renamed to `Position->getWorld()`, and `Position->level` has been renamed to `Position->world`.
+- Extracted a `WorldManager` unit from `Server`
+  - `Server->findEntity()` -> `WorldManager->findEntity()`
+  - `Server->generateLevel()` -> `WorldManager->generateWorld()`
+  - `Server->getAutoSave()` -> `WorldManager->getAutoSave()`
+  - `Server->getDefaultLevel()` -> `WorldManager->getDefaultWorld()`
+  - `Server->getLevel()` -> `WorldManager->getWorld()`
+  - `Server->getLevelByName()` -> `WorldManager->getWorldByName()`
+  - `Server->getLevels()` -> `WorldManager->getWorlds()`
+  - `Server->isLevelGenerated()` -> `WorldManager->isWorldGenerated()`
+  - `Server->isLevelLoaded()` -> `WorldManager->isWorldLoaded()`
+  - `Server->loadLevel()` -> `WorldManager->loadWorld()`
+  - `Server->setAutoSave()` -> `WorldManager->setAutoSave()`
+  - `Server->setDefaultLevel()` -> `WorldManager->setDefaultWorld()`
+  - `Server->unloadLevel()` -> `WorldManager->unloadWorld()`
+- Added `WorldManager->getAutoSaveTicks()` and `WorldManager->setAutoSaveTicks()` to allow controlling the autosave interval.
+- The following classes have been added:
+  - `BlockTransaction`: allows creating batch commits of block changes with validation conditions - if any block can't be applied, the whole transaction fails to apply.
+  - `ChunkListenerNoOpTrait`: contains default no-op stubs for chunk listener implementations
+  - `ChunkListener`: interface allowing subscribing to events happening on a given chunk
+- The following API methods have been added:
+  - `World->registerChunkListener()`
+  - `World->unregisterChunkListener()`
+- The following API methods have been removed:
+  - `ChunkLoader->getLoaderId()` (now object ID is used)
+
+- The following API methods have changed signatures:
+  - `World->addParticle()` now has the signature `addParticle(Vector3 $pos, Particle $particle, ?Player[] $players = null) : void`
+  - `World->addSound()` now has the signature `addSound(?Vector3 $pos, Sound $sound, ?Player[] $players = null) : void`
+  - `World->getRandomTickedBlocks()` now returns `bool[]` instead of `SplFixedArray`.
+  - `World->addRandomTickedBlock()` now accepts `Block` instead of `int, int`.
+  - `World->removeRandomTickedBlock()` now accepts `Block` instead of `int, int`.
+  - `World->setBlock()` has had the `$direct` parameter removed.
+- The following API methods have been renamed / moved:
+  - `Level->getCollisionCubes()` -> `World->getCollisionBoxes()`
+- Extracted a unit `pocketmine\world\format\io\FastChunkSerializer` from `Chunk`:
+  - `Chunk->fastDeserialize()` -> `FastChunkSerializer::deserialize()`
+  - `Chunk->fastSerialize()` -> `FastChunkSerializer::serialize()`
+- A `ChunkListener` interface has been extracted from `ChunkLoader`. The following methods have been moved:
+  - `ChunkLoader->onBlockChanged()` -> `ChunkListener->onBlockChanged()`
+  - `ChunkLoader->onChunkChanged()` -> `ChunkListener->onChunkChanged()`
+  - `ChunkLoader->onChunkLoaded()` -> `ChunkListener->onChunkLoaded()`
+  - `ChunkLoader->onChunkPopulated()` -> `ChunkListener->onChunkPopulated()`
+  - `ChunkLoader->onChunkUnloaded()` -> `ChunkListener->onChunkUnloaded()`
+
+#### Particles
+- `pocketmine\world\particle\Particle` no longer extends `pocketmine\math\Vector3`, and has been converted to an interface.
+- Added the following `Particle` classes:
+  - `DragonEggTeleportParticle`
+  - `PunchBlockParticle`
+
+#### Sounds
+- `pocketmine\world\sound\Sound` no longer extends `pocketmine\math\Vector3`, and has been converted to an interface.
+- `Sound->encode()` now accepts `?\pocketmine\math\Vector3`. `NULL` may be passed for sounds which are global.
+- Added the following classes:
+  - `ArrowHitSound`
+  - `BlockBreakSound`
+  - `BlockPlaceSound`
+  - `BowShootSound`
+  - `BucketEmptyLavaSound`
+  - `BucketEmptyWaterSound`
+  - `BucketFillLavaSound`
+  - `BucketFillWaterSound`
+  - `ChestCloseSound`
+  - `ChestOpenSound`
+  - `EnderChestCloseSound`
+  - `EnderChestOpenSound`
+  - `ExplodeSound`
+  - `FlintSteelSound`
+  - `ItemBreakSound`
+  - `NoteInstrument`
+  - `NoteSound`
+  - `PaintingPlaceSound`
+  - `PotionSplashSound`
+  - `RedstonePowerOffSound`
+  - `RedstonePowerOnSound`
+  - `ThrowSound`
+  - `XpCollectSound`
+  - `XpLevelUpSound`
+
+### Utils
+- `Terminal::hasFormattingCodes()` no longer auto-detects the availability of formatting codes. Instead it's necessary to use `Terminal::init()` with no parameters to initialize, or `true` or `false` to override.
+- `Config->save()` no longer catches exceptions thrown during emitting to disk.
+- The following new classes have been added:
+  - `InternetException`
+  - `Internet`
+  - `Process`
+- The following API methods have been added:
+  - `Color::fromRGBA()`
+  - `Config->getPath()`: returns the path to the config on disk
+  - `Terminal::write()`: emits a Minecraft-formatted text line without newline
+  - `Terminal::writeLine()`: emits a Minecraft-formatted text line with newline
+  - `Utils::recursiveUnlink()`: recursively deletes a directory and its contents
+- The following deprecated API redirects have been removed:
+  - `Utils::execute()`: moved to `Process`
+  - `Utils::getIP()`: moved to `Internet`
+  - `Utils::getMemoryUsage()`: moved to `Process`
+  - `Utils::getRealMemoryUsage()`: moved to `Process`
+  - `Utils::getThreadCount()`: moved to `Process`
+  - `Utils::getURL()`: moved to `Internet`
+  - `Utils::kill()`: moved to `Process`
+  - `Utils::postURL()`: moved to `Internet`
+  - `Utils::simpleCurl()`: moved to `Internet`
+- The following API fields have been removed / hidden:
+  - `Utils::$ip`
+  - `Utils::$online`
+  - `Utils::$os`
+- The following API methods have signature changes:
+  - `Internet::simpleCurl()` now requires a `Closure` for its `onSuccess` parameter instead of `callable`.
+- The following API methods have been removed:
+  - `Color->setA()`
+  - `Color->setR()`
+  - `Color->setG()`
+  - `Color->setB()`
+  - `Color->toABGR()`
+  - `Color->toBGRA()`
+  - `Color::fromABGR()`
+  - `Utils::getCallableIdentifier()`

composer.json

@@ -8,11 +8,16 @@
       "php": ">=7.2.0",
       "php-64bit": "*",
       "ext-bcmath": "*",
+      "ext-chunkutils2": "^0.1.0",
       "ext-curl": "*",
+      "ext-crypto": "^0.3.1",
       "ext-ctype": "*",
       "ext-date": "*",
+      "ext-ds": "^1.2.7",
+      "ext-gmp": "*",
       "ext-hash": "*",
       "ext-json": "*",
+      "ext-leveldb": "^0.2.1",
       "ext-mbstring": "*",
       "ext-openssl": "*",
       "ext-pcre": "*",
@@ -24,14 +29,16 @@
       "ext-yaml": ">=2.0.0",
       "ext-zip": "*",
       "ext-zlib": ">=1.2.11",
-      "pocketmine/raklib": "^0.12.5",
-      "pocketmine/spl": "^0.3.0",
+      "mdanter/ecc": "^0.5.0",
+      "pocketmine/raklib": "dev-master",
+      "pocketmine/spl": "dev-master",
       "pocketmine/binaryutils": "^0.1.9",
-      "pocketmine/nbt": "^0.2.10",
-      "pocketmine/math": "^0.2.0",
+      "pocketmine/nbt": "dev-master",
+      "pocketmine/math": "dev-master",
       "pocketmine/snooze": "^0.1.0",
       "daverandom/callback-validator": "dev-master",
-      "adhocore/json-comment": "^0.0.7"
+      "adhocore/json-comment": "^0.0.7",
+      "particle/validator": "^2.3"
    },
    "autoload": {
       "psr-4": {

composer.lock

@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "377d9e0ab5f1a9a4ef9b664706d26f5b",
+    "content-hash": "3f4e9e3e4dfdd48390caf564839e8b46",
     "packages": [
         {
             "name": "adhocore/json-comment",
@@ -90,6 +90,209 @@
             "description": "Tools for validating callback signatures",
             "time": "2017-04-03T15:22:41+00:00"
         },
+        {
+            "name": "fgrosse/phpasn1",
+            "version": "v2.1.1",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/fgrosse/PHPASN1.git",
+                "reference": "7ebf2a09084a7bbdb7b879c66fdf7ad80461bbe8"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/fgrosse/PHPASN1/zipball/7ebf2a09084a7bbdb7b879c66fdf7ad80461bbe8",
+                "reference": "7ebf2a09084a7bbdb7b879c66fdf7ad80461bbe8",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=7.0.0"
+            },
+            "require-dev": {
+                "phpunit/phpunit": "~6.3",
+                "satooshi/php-coveralls": "~2.0"
+            },
+            "suggest": {
+                "ext-gmp": "GMP is the preferred extension for big integer calculations",
+                "php-curl": "For loading OID information from the web if they have not bee defined statically"
+            },
+            "type": "library",
+            "extra": {
+                "branch-alias": {
+                    "dev-master": "2.0.x-dev"
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "FG\\": "lib/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Friedrich Große",
+                    "email": "friedrich.grosse@gmail.com",
+                    "homepage": "https://github.com/FGrosse",
+                    "role": "Author"
+                },
+                {
+                    "name": "All contributors",
+                    "homepage": "https://github.com/FGrosse/PHPASN1/contributors"
+                }
+            ],
+            "description": "A PHP Framework that allows you to encode and decode arbitrary ASN.1 structures using the ITU-T X.690 Encoding Rules.",
+            "homepage": "https://github.com/FGrosse/PHPASN1",
+            "keywords": [
+                "DER",
+                "asn.1",
+                "asn1",
+                "ber",
+                "binary",
+                "decoding",
+                "encoding",
+                "x.509",
+                "x.690",
+                "x509",
+                "x690"
+            ],
+            "time": "2018-12-02T01:34:34+00:00"
+        },
+        {
+            "name": "mdanter/ecc",
+            "version": "v0.5.2",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/phpecc/phpecc.git",
+                "reference": "b95f25cc1bacc83a9f0ccd375900b7cfd343029e"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/phpecc/phpecc/zipball/b95f25cc1bacc83a9f0ccd375900b7cfd343029e",
+                "reference": "b95f25cc1bacc83a9f0ccd375900b7cfd343029e",
+                "shasum": ""
+            },
+            "require": {
+                "ext-gmp": "*",
+                "fgrosse/phpasn1": "^2.0",
+                "php": "^7.0"
+            },
+            "require-dev": {
+                "phpunit/phpunit": "^6.0",
+                "squizlabs/php_codesniffer": "^2.0",
+                "symfony/yaml": "^2.6|^3.0"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "Mdanter\\Ecc\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Matyas Danter",
+                    "homepage": "http://matejdanter.com/",
+                    "role": "Author"
+                },
+                {
+                    "name": "Thibaud Fabre",
+                    "email": "thibaud@aztech.io",
+                    "homepage": "http://aztech.io",
+                    "role": "Maintainer"
+                },
+                {
+                    "name": "Thomas Kerin",
+                    "email": "afk11@users.noreply.github.com",
+                    "role": "Maintainer"
+                }
+            ],
+            "description": "PHP Elliptic Curve Cryptography library",
+            "homepage": "https://github.com/phpecc/phpecc",
+            "keywords": [
+                "Diffie",
+                "ECDSA",
+                "Hellman",
+                "curve",
+                "ecdh",
+                "elliptic",
+                "nistp192",
+                "nistp224",
+                "nistp256",
+                "nistp384",
+                "nistp521",
+                "phpecc",
+                "secp256k1",
+                "secp256r1"
+            ],
+            "time": "2018-12-03T18:17:01+00:00"
+        },
+        {
+            "name": "particle/validator",
+            "version": "v2.3.4",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/particle-php/Validator.git",
+                "reference": "657c7543e51938dd9d114750e49d695129527a7a"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/particle-php/Validator/zipball/657c7543e51938dd9d114750e49d695129527a7a",
+                "reference": "657c7543e51938dd9d114750e49d695129527a7a",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=5.4"
+            },
+            "require-dev": {
+                "byrokrat/checkdigit": "^1.0",
+                "giggsey/libphonenumber-for-php": "^7.2",
+                "phpunit/phpunit": "~4.0",
+                "squizlabs/php_codesniffer": "2.*"
+            },
+            "suggest": {
+                "byrokrat/checkdigit": "If you want to use CreditCard validation rule, this library must be installed.",
+                "giggsey/libphonenumber-for-php": "If you want to use Phone validation rule, this library must be installed."
+            },
+            "type": "library",
+            "extra": {
+                "branch-alias": {
+                    "dev-master": "2.0-dev"
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "Particle\\Validator\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "BSD-3-Clause"
+            ],
+            "authors": [
+                {
+                    "name": "Berry Langerak",
+                    "email": "berry@berryllium.nl",
+                    "role": "Developer"
+                },
+                {
+                    "name": "Rick van der Staaij",
+                    "homepage": "http://rickvanderstaaij.nl",
+                    "role": "Developer"
+                }
+            ],
+            "description": "Flexible and highly usable validation library with no dependencies.",
+            "homepage": "http://github.com/particle-php/validator",
+            "keywords": [
+                "validation",
+                "validator"
+            ],
+            "time": "2019-01-07T13:39:13+00:00"
+        },
         {
             "name": "pocketmine/binaryutils",
             "version": "0.1.9",
@@ -126,16 +329,16 @@
         },
         {
             "name": "pocketmine/math",
-            "version": "0.2.2",
+            "version": "dev-master",
             "source": {
                 "type": "git",
                 "url": "https://github.com/pmmp/Math.git",
-                "reference": "b755d3fb7025c4ddb7d9d6df0ba7e0b65125e51c"
+                "reference": "d436a98b85edd18d7b1542fab66827b1e6fc8d68"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/pmmp/Math/zipball/b755d3fb7025c4ddb7d9d6df0ba7e0b65125e51c",
-                "reference": "b755d3fb7025c4ddb7d9d6df0ba7e0b65125e51c",
+                "url": "https://api.github.com/repos/pmmp/Math/zipball/d436a98b85edd18d7b1542fab66827b1e6fc8d68",
+                "reference": "d436a98b85edd18d7b1542fab66827b1e6fc8d68",
                 "shasum": ""
             },
             "require": {
@@ -148,28 +351,33 @@
                     "pocketmine\\math\\": "src/"
                 }
             },
+            "autoload-dev": {
+                "psr-4": {
+                    "pocketmine\\math\\": "tests/phpunit/"
+                }
+            },
             "license": [
                 "LGPL-3.0"
             ],
             "description": "PHP library containing math related code used in PocketMine-MP",
             "support": {
-                "source": "https://github.com/pmmp/Math/tree/0.2.2",
+                "source": "https://github.com/pmmp/Math/tree/master",
                 "issues": "https://github.com/pmmp/Math/issues"
             },
-            "time": "2019-01-04T15:42:36+00:00"
+            "time": "2019-07-29T16:46:11+00:00"
         },
         {
             "name": "pocketmine/nbt",
-            "version": "0.2.10",
+            "version": "dev-master",
             "source": {
                 "type": "git",
                 "url": "https://github.com/pmmp/NBT.git",
-                "reference": "2db27aebe7dc89772aaa8df53361eef801f60063"
+                "reference": "0976fcea814978c4ca7e53f5c19e459ae8e341e5"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/pmmp/NBT/zipball/2db27aebe7dc89772aaa8df53361eef801f60063",
-                "reference": "2db27aebe7dc89772aaa8df53361eef801f60063",
+                "url": "https://api.github.com/repos/pmmp/NBT/zipball/0976fcea814978c4ca7e53f5c19e459ae8e341e5",
+                "reference": "0976fcea814978c4ca7e53f5c19e459ae8e341e5",
                 "shasum": ""
             },
             "require": {
@@ -194,23 +402,23 @@
             ],
             "description": "PHP library for working with Named Binary Tags",
             "support": {
-                "source": "https://github.com/pmmp/NBT/tree/0.2.10",
+                "source": "https://github.com/pmmp/NBT/tree/master",
                 "issues": "https://github.com/pmmp/NBT/issues"
             },
-            "time": "2019-07-22T15:22:23+00:00"
+            "time": "2019-07-22T15:30:11+00:00"
         },
         {
             "name": "pocketmine/raklib",
-            "version": "0.12.5",
+            "version": "dev-master",
             "source": {
                 "type": "git",
                 "url": "https://github.com/pmmp/RakLib.git",
-                "reference": "874db2d3c24117db2221c1e4550380478aeea852"
+                "reference": "df98f7e1a67629ee743939318810d3d2bafc5ba3"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/pmmp/RakLib/zipball/874db2d3c24117db2221c1e4550380478aeea852",
-                "reference": "874db2d3c24117db2221c1e4550380478aeea852",
+                "url": "https://api.github.com/repos/pmmp/RakLib/zipball/df98f7e1a67629ee743939318810d3d2bafc5ba3",
+                "reference": "df98f7e1a67629ee743939318810d3d2bafc5ba3",
                 "shasum": ""
             },
             "require": {
@@ -222,7 +430,7 @@
                 "php-ipv6": "*",
                 "pocketmine/binaryutils": "^0.1.9",
                 "pocketmine/snooze": "^0.1.0",
-                "pocketmine/spl": "^0.3.0"
+                "pocketmine/spl": "dev-master"
             },
             "type": "library",
             "autoload": {
@@ -235,10 +443,10 @@
             ],
             "description": "A RakNet server implementation written in PHP",
             "support": {
-                "source": "https://github.com/pmmp/RakLib/tree/0.12",
+                "source": "https://github.com/pmmp/RakLib/tree/master",
                 "issues": "https://github.com/pmmp/RakLib/issues"
             },
-            "time": "2019-07-22T14:38:20+00:00"
+            "time": "2019-07-22T15:27:51+00:00"
         },
         {
             "name": "pocketmine/snooze",
@@ -276,23 +484,20 @@
         },
         {
             "name": "pocketmine/spl",
-            "version": "0.3.2",
+            "version": "dev-master",
             "source": {
                 "type": "git",
                 "url": "https://github.com/pmmp/SPL.git",
-                "reference": "7fd53857cd000491ba69e8db865792a024dd2c49"
+                "reference": "49a4b0187f2aa9daa1a9457aefa1f4cbcc5ead92"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/pmmp/SPL/zipball/7fd53857cd000491ba69e8db865792a024dd2c49",
-                "reference": "7fd53857cd000491ba69e8db865792a024dd2c49",
+                "url": "https://api.github.com/repos/pmmp/SPL/zipball/49a4b0187f2aa9daa1a9457aefa1f4cbcc5ead92",
+                "reference": "49a4b0187f2aa9daa1a9457aefa1f4cbcc5ead92",
                 "shasum": ""
             },
             "type": "library",
             "autoload": {
-                "exclude-from-classmap": [
-                    "stubs"
-                ],
                 "classmap": [
                     "./"
                 ]
@@ -304,13 +509,17 @@
             "support": {
                 "source": "https://github.com/pmmp/SPL/tree/master"
             },
-            "time": "2018-08-12T15:17:39+00:00"
+            "time": "2019-07-20T14:32:24+00:00"
         }
     ],
     "packages-dev": [],
     "aliases": [],
     "minimum-stability": "stable",
     "stability-flags": {
+        "pocketmine/raklib": 20,
+        "pocketmine/spl": 20,
+        "pocketmine/nbt": 20,
+        "pocketmine/math": 20,
         "daverandom/callback-validator": 20
     },
     "prefer-stable": false,
@@ -319,11 +528,16 @@
         "php": ">=7.2.0",
         "php-64bit": "*",
         "ext-bcmath": "*",
+        "ext-chunkutils2": "^0.1.0",
         "ext-curl": "*",
+        "ext-crypto": "^0.3.1",
         "ext-ctype": "*",
         "ext-date": "*",
+        "ext-ds": "^1.2.7",
+        "ext-gmp": "*",
         "ext-hash": "*",
         "ext-json": "*",
+        "ext-leveldb": "^0.2.1",
         "ext-mbstring": "*",
         "ext-openssl": "*",
         "ext-pcre": "*",

resources/plugin_list.yml

@@ -0,0 +1,8 @@
+#This configuration file allows you to control which plugins are loaded on your server.
+
+#List behaviour
+# - blacklist: Only plugins which ARE NOT listed will load.
+# - whitelist: Only plugins which ARE listed will load.
+mode: blacklist
+#List names of plugins here.
+plugins: []

resources/pocketmine.yml

@@ -94,6 +94,9 @@ network:
   #Maximum size in bytes of packets sent over the network (default 1492 bytes). Packets larger than this will be
   #fragmented or split into smaller parts. Clients can request MTU sizes up to but not more than this number.
   max-mtu-size: 1492
+  #Enable encryption of Minecraft network traffic. This has an impact on performance, but prevents hackers from stealing sessions and pretending to be other players.
+  #DO NOT DISABLE THIS unless you understand the risks involved.
+  enable-encryption: true
 
 debug:
   #If > 1, it will show debug messages in the console
@@ -102,13 +105,10 @@ debug:
 player:
   #Choose whether to enable player data saving.
   save-player-data: true
-  anti-cheat:
-    #If false, will try to prevent speed and noclip cheats. May cause movement issues.
-    allow-movement-cheats: true
 
 level-settings:
   #The default format that levels will use when created
-  default-format: pmanvil
+  default-format: leveldb
 
 chunk-sending:
   #To change server normal render distance, change view-distance in server.properties.
@@ -122,8 +122,6 @@ chunk-ticking:
   per-tick: 40
   #Radius of chunks around a player to tick
   tick-radius: 3
-  light-updates: false
-  clear-tick-list: true
   #IDs of blocks not to perform random ticking on.
   disable-block-ticking:
     #- 2 # grass

src/pocketmine/Achievement.php

@@ -1,150 +0,0 @@
-<?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;
-
-use pocketmine\lang\TranslationContainer;
-use pocketmine\utils\TextFormat;
-
-/**
- * Handles the achievement list and a bit more
- */
-abstract class Achievement{
-	/**
-	 * @var array[]
-	 */
-	public static $list = [
-		/*"openInventory" => array(
-			"name" => "Taking Inventory",
-			"requires" => [],
-		),*/
-		"mineWood" => [
-			"name" => "Getting Wood",
-			"requires" => [ //"openInventory",
-			]
-		],
-		"buildWorkBench" => [
-			"name" => "Benchmarking",
-			"requires" => [
-				"mineWood"
-			]
-		],
-		"buildPickaxe" => [
-			"name" => "Time to Mine!",
-			"requires" => [
-				"buildWorkBench"
-			]
-		],
-		"buildFurnace" => [
-			"name" => "Hot Topic",
-			"requires" => [
-				"buildPickaxe"
-			]
-		],
-		"acquireIron" => [
-			"name" => "Acquire hardware",
-			"requires" => [
-				"buildFurnace"
-			]
-		],
-		"buildHoe" => [
-			"name" => "Time to Farm!",
-			"requires" => [
-				"buildWorkBench"
-			]
-		],
-		"makeBread" => [
-			"name" => "Bake Bread",
-			"requires" => [
-				"buildHoe"
-			]
-		],
-		"bakeCake" => [
-			"name" => "The Lie",
-			"requires" => [
-				"buildHoe"
-			]
-		],
-		"buildBetterPickaxe" => [
-			"name" => "Getting an Upgrade",
-			"requires" => [
-				"buildPickaxe"
-			]
-		],
-		"buildSword" => [
-			"name" => "Time to Strike!",
-			"requires" => [
-				"buildWorkBench"
-			]
-		],
-		"diamonds" => [
-			"name" => "DIAMONDS!",
-			"requires" => [
-				"acquireIron"
-			]
-		]
-
-	];
-
-
-	/**
-	 * @param Player $player
-	 * @param string $achievementId
-	 *
-	 * @return bool
-	 */
-	public static function broadcast(Player $player, string $achievementId) : bool{
-		if(isset(Achievement::$list[$achievementId])){
-			$translation = new TranslationContainer("chat.type.achievement", [$player->getDisplayName(), TextFormat::GREEN . Achievement::$list[$achievementId]["name"] . TextFormat::RESET]);
-			if(Server::getInstance()->getConfigBool("announce-player-achievements", true)){
-				Server::getInstance()->broadcastMessage($translation);
-			}else{
-				$player->sendMessage($translation);
-			}
-
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * @param string $achievementId
-	 * @param string $achievementName
-	 * @param array  $requires
-	 *
-	 * @return bool
-	 */
-	public static function add(string $achievementId, string $achievementName, array $requires = []) : bool{
-		if(!isset(Achievement::$list[$achievementId])){
-			Achievement::$list[$achievementId] = [
-				"name" => $achievementName,
-				"requires" => $requires
-			];
-
-			return true;
-		}
-
-		return false;
-	}
-}

src/pocketmine/CrashDump.php

@@ -25,7 +25,6 @@ namespace pocketmine;
 
 use pocketmine\network\mcpe\protocol\ProtocolInfo;
 use pocketmine\plugin\PluginBase;
-use pocketmine\plugin\PluginLoadOrder;
 use pocketmine\plugin\PluginManager;
 use pocketmine\utils\Utils;
 use pocketmine\utils\VersionString;
@@ -56,25 +55,11 @@ use function phpversion;
 use function preg_replace;
 use function str_split;
 use function strpos;
+use function strtoupper;
 use function substr;
 use function time;
 use function zend_version;
 use function zlib_encode;
-use const E_COMPILE_ERROR;
-use const E_COMPILE_WARNING;
-use const E_CORE_ERROR;
-use const E_CORE_WARNING;
-use const E_DEPRECATED;
-use const E_ERROR;
-use const E_NOTICE;
-use const E_PARSE;
-use const E_RECOVERABLE_ERROR;
-use const E_STRICT;
-use const E_USER_DEPRECATED;
-use const E_USER_ERROR;
-use const E_USER_NOTICE;
-use const E_USER_WARNING;
-use const E_WARNING;
 use const FILE_IGNORE_NEW_LINES;
 use const JSON_UNESCAPED_SLASHES;
 use const PHP_EOL;
@@ -134,7 +119,7 @@ class CrashDump{
 		return $this->path;
 	}
 
-	public function getEncodedData(){
+	public function getEncodedData() : string{
 		return $this->encodedData;
 	}
 
@@ -142,7 +127,7 @@ class CrashDump{
 		return $this->data;
 	}
 
-	private function encodeData(){
+	private function encodeData() : void{
 		$this->addLine();
 		$this->addLine("----------------------REPORT THE DATA BELOW THIS LINE-----------------------");
 		$this->addLine();
@@ -158,7 +143,7 @@ class CrashDump{
 		$this->addLine("===END CRASH DUMP===");
 	}
 
-	private function pluginsData(){
+	private function pluginsData() : void{
 		if($this->server->getPluginManager() instanceof PluginManager){
 			$this->addLine();
 			$this->addLine("Loaded plugins:");
@@ -174,7 +159,7 @@ class CrashDump{
 					"depends" => $d->getDepend(),
 					"softDepends" => $d->getSoftDepend(),
 					"main" => $d->getMain(),
-					"load" => $d->getOrder() === PluginLoadOrder::POSTWORLD ? "POSTWORLD" : "STARTUP",
+					"load" => strtoupper($d->getOrder()->name()),
 					"website" => $d->getWebsite()
 				];
 				$this->addLine($d->getName() . " " . $d->getVersion() . " by " . implode(", ", $d->getAuthors()) . " for API(s) " . implode(", ", $d->getCompatibleApis()));
@@ -182,7 +167,7 @@ class CrashDump{
 		}
 	}
 
-	private function extraData(){
+	private function extraData() : void{
 		global $argv;
 
 		if($this->server->getProperty("auto-report.send-settings", true) !== false){
@@ -209,7 +194,7 @@ class CrashDump{
 		}
 	}
 
-	private function baseCrash(){
+	private function baseCrash() : void{
 		global $lastExceptionError, $lastError;
 
 		if(isset($lastExceptionError)){
@@ -217,26 +202,13 @@ class CrashDump{
 		}else{
 			$error = (array) error_get_last();
 			$error["trace"] = Utils::currentTrace(3); //Skipping CrashDump->baseCrash, CrashDump->construct, Server->crashDump
-			$errorConversion = [
-				E_ERROR => "E_ERROR",
-				E_WARNING => "E_WARNING",
-				E_PARSE => "E_PARSE",
-				E_NOTICE => "E_NOTICE",
-				E_CORE_ERROR => "E_CORE_ERROR",
-				E_CORE_WARNING => "E_CORE_WARNING",
-				E_COMPILE_ERROR => "E_COMPILE_ERROR",
-				E_COMPILE_WARNING => "E_COMPILE_WARNING",
-				E_USER_ERROR => "E_USER_ERROR",
-				E_USER_WARNING => "E_USER_WARNING",
-				E_USER_NOTICE => "E_USER_NOTICE",
-				E_STRICT => "E_STRICT",
-				E_RECOVERABLE_ERROR => "E_RECOVERABLE_ERROR",
-				E_DEPRECATED => "E_DEPRECATED",
-				E_USER_DEPRECATED => "E_USER_DEPRECATED"
-			];
 			$error["fullFile"] = $error["file"];
 			$error["file"] = Utils::cleanPath($error["file"]);
-			$error["type"] = $errorConversion[$error["type"]] ?? $error["type"];
+			try{
+				$error["type"] = \ErrorUtils::errorTypeToString($error["type"]);
+			}catch(\InvalidArgumentException $e){
+				//pass
+			}
 			if(($pos = strpos($error["message"], "\n")) !== false){
 				$error["message"] = substr($error["message"], 0, $pos);
 			}
@@ -317,7 +289,7 @@ class CrashDump{
 		return false;
 	}
 
-	private function generalData(){
+	private function generalData() : void{
 		$version = new VersionString(\pocketmine\BASE_VERSION, \pocketmine\IS_DEVELOPMENT_BUILD, \pocketmine\BUILD_NUMBER);
 		$this->data["general"] = [];
 		$this->data["general"]["name"] = $this->server->getName();
@@ -340,11 +312,11 @@ class CrashDump{
 		$this->addLine("OS : " . PHP_OS . ", " . Utils::getOS());
 	}
 
-	public function addLine($line = ""){
+	public function addLine($line = "") : void{
 		fwrite($this->fp, $line . PHP_EOL);
 	}
 
-	public function add($str){
+	public function add($str) : void{
 		fwrite($this->fp, $str);
 	}
 }

src/pocketmine/MemoryManager.php

@@ -27,6 +27,7 @@ use pocketmine\event\server\LowMemoryEvent;
 use pocketmine\scheduler\DumpWorkerMemoryTask;
 use pocketmine\scheduler\GarbageCollectionTask;
 use pocketmine\timings\Timings;
+use pocketmine\utils\Process;
 use pocketmine\utils\Utils;
 use function arsort;
 use function count;
@@ -109,13 +110,17 @@ class MemoryManager{
 	/** @var bool */
 	private $dumpWorkers = true;
 
+	/** @var \Logger */
+	private $logger;
+
 	public function __construct(Server $server){
 		$this->server = $server;
+		$this->logger = new \PrefixedLogger($server->getLogger(), "Memory Manager");
 
 		$this->init();
 	}
 
-	private function init(){
+	private function init() : void{
 		$this->memoryLimit = ((int) $this->server->getProperty("memory.main-limit", 0)) * 1024 * 1024;
 
 		$defaultMemory = 1024;
@@ -176,6 +181,13 @@ class MemoryManager{
 		return $this->lowMemory;
 	}
 
+	/**
+	 * @return int
+	 */
+	public function getGlobalMemoryLimit() : int{
+		return $this->globalMemoryLimit;
+	}
+
 	/**
 	 * @return bool
 	 */
@@ -202,18 +214,18 @@ class MemoryManager{
 	 * @param bool $global
 	 * @param int  $triggerCount
 	 */
-	public function trigger(int $memory, int $limit, bool $global = false, int $triggerCount = 0){
-		$this->server->getLogger()->debug(sprintf("[Memory Manager] %sLow memory triggered, limit %gMB, using %gMB",
+	public function trigger(int $memory, int $limit, bool $global = false, int $triggerCount = 0) : void{
+		$this->logger->debug(sprintf("%sLow memory triggered, limit %gMB, using %gMB",
 			$global ? "Global " : "", round(($limit / 1024) / 1024, 2), round(($memory / 1024) / 1024, 2)));
 		if($this->lowMemClearWorldCache){
-			foreach($this->server->getLevels() as $level){
-				$level->clearCache(true);
+			foreach($this->server->getWorldManager()->getWorlds() as $world){
+				$world->clearCache(true);
 			}
 		}
 
 		if($this->lowMemChunkGC){
-			foreach($this->server->getLevels() as $level){
-				$level->doChunkGarbageCollection();
+			foreach($this->server->getWorldManager()->getWorlds() as $world){
+				$world->doChunkGarbageCollection();
 			}
 		}
 
@@ -225,18 +237,18 @@ class MemoryManager{
 			$cycles = $this->triggerGarbageCollector();
 		}
 
-		$this->server->getLogger()->debug(sprintf("[Memory Manager] Freed %gMB, $cycles cycles", round(($ev->getMemoryFreed() / 1024) / 1024, 2)));
+		$this->logger->debug(sprintf("Freed %gMB, $cycles cycles", round(($ev->getMemoryFreed() / 1024) / 1024, 2)));
 	}
 
 	/**
 	 * Called every tick to update the memory manager state.
 	 */
-	public function check(){
+	public function check() : void{
 		Timings::$memoryManagerTimer->startTiming();
 
 		if(($this->memoryLimit > 0 or $this->globalMemoryLimit > 0) and ++$this->checkTicker >= $this->checkRate){
 			$this->checkTicker = 0;
-			$memory = Utils::getMemoryUsage(true);
+			$memory = Process::getMemoryUsage(true);
 			$trigger = false;
 			if($this->memoryLimit > 0 and $memory[0] > $this->memoryLimit){
 				$trigger = 0;
@@ -277,7 +289,7 @@ class MemoryManager{
 		if($this->garbageCollectionAsync){
 			$pool = $this->server->getAsyncPool();
 			if(($w = $pool->shutdownUnusedWorkers()) > 0){
-				$this->server->getLogger()->debug("Shut down $w idle async pool workers");
+				$this->logger->debug("Shut down $w idle async pool workers");
 			}
 			foreach($pool->getRunningWorkers() as $i){
 				$pool->submitTaskToWorker(new GarbageCollectionTask(), $i);
@@ -298,9 +310,10 @@ class MemoryManager{
 	 * @param int    $maxNesting
 	 * @param int    $maxStringSize
 	 */
-	public function dumpServerMemory(string $outputFolder, int $maxNesting, int $maxStringSize){
-		$this->server->getLogger()->notice("[Dump] After the memory dump is done, the server might crash");
-		self::dumpMemory($this->server, $outputFolder, $maxNesting, $maxStringSize, $this->server->getLogger());
+	public function dumpServerMemory(string $outputFolder, int $maxNesting, int $maxStringSize) : void{
+		$logger = new \PrefixedLogger($this->server->getLogger(), "Memory Dump");
+		$logger->notice("After the memory dump is done, the server might crash");
+		self::dumpMemory($this->server, $outputFolder, $maxNesting, $maxStringSize, $logger);
 
 		if($this->dumpWorkers){
 			$pool = $this->server->getAsyncPool();
@@ -321,7 +334,7 @@ class MemoryManager{
 	 *
 	 * @throws \ReflectionException
 	 */
-	public static function dumpMemory($startingObject, string $outputFolder, int $maxNesting, int $maxStringSize, \Logger $logger){
+	public static function dumpMemory($startingObject, string $outputFolder, int $maxNesting, int $maxStringSize, \Logger $logger) : void{
 		$hardLimit = ini_get('memory_limit');
 		ini_set('memory_limit', '-1');
 		gc_disable();
@@ -365,7 +378,7 @@ class MemoryManager{
 		}
 
 		file_put_contents($outputFolder . "/staticProperties.js", json_encode($staticProperties, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
-		$logger->info("[Dump] Wrote $staticCount static properties");
+		$logger->info("Wrote $staticCount static properties");
 
 		if(isset($GLOBALS)){ //This might be null if we're on a different thread
 			$globalVariables = [];
@@ -393,7 +406,7 @@ class MemoryManager{
 			}
 
 			file_put_contents($outputFolder . "/globalVariables.js", json_encode($globalVariables, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
-			$logger->info("[Dump] Wrote $globalCount global variables");
+			$logger->info("Wrote $globalCount global variables");
 		}
 
 		self::continueDump($startingObject, $data, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
@@ -454,7 +467,7 @@ class MemoryManager{
 
 		}while($continue);
 
-		$logger->info("[Dump] Wrote " . count($objects) . " objects");
+		$logger->info("Wrote " . count($objects) . " objects");
 
 		fclose($obData);
 
@@ -464,7 +477,7 @@ class MemoryManager{
 		arsort($instanceCounts, SORT_NUMERIC);
 		file_put_contents($outputFolder . "/instanceCounts.js", json_encode($instanceCounts, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
 
-		$logger->info("[Dump] Finished!");
+		$logger->info("Finished!");
 
 		ini_set('memory_limit', $hardLimit);
 		gc_enable();
@@ -479,7 +492,7 @@ class MemoryManager{
 	 * @param int      $maxNesting
 	 * @param int      $maxStringSize
 	 */
-	private static function continueDump($from, &$data, array &$objects, array &$refCounts, int $recursion, int $maxNesting, int $maxStringSize){
+	private static function continueDump($from, &$data, array &$objects, array &$refCounts, int $recursion, int $maxNesting, int $maxStringSize) : void{
 		if($maxNesting <= 0){
 			$data = "(error) NESTING LIMIT REACHED";
 			return;

src/pocketmine/PocketMine.php

@@ -28,11 +28,12 @@ namespace {
 
 namespace pocketmine {
 
+	use pocketmine\thread\ThreadManager;
 	use pocketmine\utils\MainLogger;
+	use pocketmine\utils\Process;
 	use pocketmine\utils\ServerKiller;
 	use pocketmine\utils\Terminal;
 	use pocketmine\utils\Timezone;
-	use pocketmine\utils\Utils;
 	use pocketmine\utils\VersionString;
 	use pocketmine\wizard\SetupWizard;
 
@@ -73,11 +74,16 @@ namespace pocketmine {
 
 		$extensions = [
 			"bcmath" => "BC Math",
+			"chunkutils2" => "PocketMine ChunkUtils v2",
 			"curl" => "cURL",
+			"crypto" => "php-crypto",
 			"ctype" => "ctype",
 			"date" => "Date",
+			"ds" => "Data Structures",
+			"gmp" => "GMP",
 			"hash" => "Hash",
 			"json" => "JSON",
+			"leveldb" => "LevelDB",
 			"mbstring" => "Multibyte String",
 			"openssl" => "OpenSSL",
 			"pcre" => "PCRE",
@@ -153,13 +159,16 @@ namespace pocketmine {
 
 		if(\pocketmine\COMPOSER_AUTOLOADER_PATH !== false and is_file(\pocketmine\COMPOSER_AUTOLOADER_PATH)){
 			require_once(\pocketmine\COMPOSER_AUTOLOADER_PATH);
+			if(extension_loaded('parallel')){
+				\parallel\bootstrap(\pocketmine\COMPOSER_AUTOLOADER_PATH);
+			}
 		}else{
 			critical_error("Composer autoloader not found at " . $bootstrap);
 			critical_error("Please install/update Composer dependencies or use provided builds.");
 			exit(1);
 		}
 
-		set_error_handler([Utils::class, 'errorExceptionHandler']);
+		\ErrorUtils::setErrorExceptionHandler();
 
 		/*
 		 * We now use the Composer autoloader, but this autoloader is still for loading plugins.
@@ -176,7 +185,7 @@ namespace pocketmine {
 
 		ini_set("memory_limit", '-1');
 
-		define('pocketmine\RESOURCE_PATH', \pocketmine\PATH . 'src' . DIRECTORY_SEPARATOR . 'pocketmine' . DIRECTORY_SEPARATOR . 'resources' . DIRECTORY_SEPARATOR);
+		define('pocketmine\RESOURCE_PATH', \pocketmine\PATH . 'resources' . DIRECTORY_SEPARATOR);
 
 		$opts = getopt("", ["data:", "plugins:", "no-wizard", "enable-ansi", "disable-ansi"]);
 
@@ -204,7 +213,7 @@ namespace pocketmine {
 		flock(\pocketmine\LOCK_FILE, LOCK_SH); //prevent acquiring an exclusive lock from another process, but allow reading
 
 		//Logger has a dependency on timezone
-		$tzError = Timezone::init();
+		Timezone::init();
 
 		if(isset($opts["enable-ansi"])){
 			Terminal::init(true);
@@ -215,19 +224,11 @@ namespace pocketmine {
 		}
 
 		$logger = new MainLogger(\pocketmine\DATA . "server.log");
-		$logger->registerStatic();
-
-		foreach($tzError as $e){
-			$logger->warning($e);
-		}
-		unset($tzError);
+		\GlobalLogger::set($logger);
 
 		if(extension_loaded("xdebug")){
 			$logger->warning(PHP_EOL . PHP_EOL . PHP_EOL . "\tYou are running " . \pocketmine\NAME . " with xdebug enabled. This has a major impact on performance." . PHP_EOL . PHP_EOL);
 		}
-		if(!extension_loaded("pocketmine_chunkutils")){
-			$logger->warning("ChunkUtils extension is missing. Anvil-format worlds will experience degraded performance.");
-		}
 
 		if(\Phar::running(true) === ""){
 			$logger->warning("Non-packaged " . \pocketmine\NAME . " installation detected. Consider using a phar in production for better performance.");
@@ -239,9 +240,9 @@ namespace pocketmine {
 		$gitHash = str_repeat("00", 20);
 
 		if(\Phar::running(true) === ""){
-			if(Utils::execute("git rev-parse HEAD", $out) === 0 and $out !== false and strlen($out = trim($out)) === 40){
+			if(Process::execute("git rev-parse HEAD", $out) === 0 and $out !== false and strlen($out = trim($out)) === 40){
 				$gitHash = trim($out);
-				if(Utils::execute("git diff --quiet") === 1 or Utils::execute("git diff --cached --quiet") === 1){ //Locally-modified
+				if(Process::execute("git diff --quiet") === 1 or Process::execute("git diff --cached --quiet") === 1){ //Locally-modified
 					$gitHash .= "-dirty";
 				}
 			}
@@ -284,7 +285,7 @@ namespace pocketmine {
 				if(\pocketmine\DEBUG > 1){
 					echo "Some threads could not be stopped, performing a force-kill" . PHP_EOL . PHP_EOL;
 				}
-				Utils::kill(getmypid());
+				Process::kill(getmypid());
 			}
 		}while(false);
 

src/pocketmine/VersionInfo.php

@@ -22,6 +22,6 @@
 namespace pocketmine;
 
 const NAME = "PocketMine-MP";
-const BASE_VERSION = "3.9.4";
+const BASE_VERSION = "4.0.0";
 const IS_DEVELOPMENT_BUILD = true;
 const BUILD_NUMBER = 0;

src/pocketmine/block/ActivatorRail.php

@@ -25,11 +25,5 @@ namespace pocketmine\block;
 
 class ActivatorRail extends RedstoneRail{
 
-	protected $id = self::ACTIVATOR_RAIL;
-
-	public function getName() : string{
-		return "Activator Rail";
-	}
-
 	//TODO
 }

src/pocketmine/block/Air.php

@@ -23,31 +23,15 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
 
-
 /**
  * Air block
  */
 class Air extends Transparent{
 
-	protected $id = self::AIR;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Air";
-	}
-
-	public function canPassThrough() : bool{
-		return true;
-	}
-
-	public function isBreakable(Item $item) : bool{
-		return false;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? BlockBreakInfo::indestructible(0.0));
 	}
 
 	public function canBeFlowedInto() : bool{
@@ -73,12 +57,4 @@ class Air extends Transparent{
 	public function getCollisionBoxes() : array{
 		return [];
 	}
-
-	public function getHardness() : float{
-		return -1;
-	}
-
-	public function getBlastResistance() : float{
-		return 0;
-	}
 }

src/pocketmine/block/Anvil.php

@@ -23,93 +23,60 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\block\utils\Fallable;
+use pocketmine\block\utils\FallableTrait;
 use pocketmine\inventory\AnvilInventory;
 use pocketmine\item\Item;
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
-class Anvil extends Fallable{
+class Anvil extends Transparent implements Fallable{
+	use FallableTrait;
 
-	public const TYPE_NORMAL = 0;
-	public const TYPE_SLIGHTLY_DAMAGED = 4;
-	public const TYPE_VERY_DAMAGED = 8;
+	/** @var int */
+	protected $facing = Facing::NORTH;
 
-	protected $id = self::ANVIL;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(5.0, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel(), 6000.0));
 	}
 
-	public function isTransparent() : bool{
-		return true;
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeLegacyHorizontalFacing($this->facing);
 	}
 
-	public function getHardness() : float{
-		return 5;
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readLegacyHorizontalFacing($stateMeta);
 	}
 
-	public function getBlastResistance() : float{
-		return 6000;
+	public function getStateBitmask() : int{
+		return 0b11;
 	}
 
-	public function getVariantBitmask() : int{
-		return 0x0c;
+	protected function recalculateBoundingBox() : ?AxisAlignedBB{
+		return AxisAlignedBB::one()->squash(Facing::axis(Facing::rotateY($this->facing, false)), 1 / 8);
 	}
 
-	public function getName() : string{
-		static $names = [
-			self::TYPE_NORMAL => "Anvil",
-			self::TYPE_SLIGHTLY_DAMAGED => "Slightly Damaged Anvil",
-			self::TYPE_VERY_DAMAGED => "Very Damaged Anvil"
-		];
-		return $names[$this->getVariant()] ?? "Anvil";
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
-	}
-
-	public function recalculateBoundingBox() : ?AxisAlignedBB{
-		$inset = 0.125;
-
-		if($this->meta & 0x01){ //east/west
-			return new AxisAlignedBB(
-				$this->x,
-				$this->y,
-				$this->z + $inset,
-				$this->x + 1,
-				$this->y + 1,
-				$this->z + 1 - $inset
-			);
-		}else{
-			return new AxisAlignedBB(
-				$this->x + $inset,
-				$this->y,
-				$this->z,
-				$this->x + 1 - $inset,
-				$this->y + 1,
-				$this->z + 1
-			);
-		}
-	}
-
-	public function onActivate(Item $item, Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player instanceof Player){
-			$player->addWindow(new AnvilInventory($this));
+			$player->setCurrentWindow(new AnvilInventory($this));
 		}
 
 		return true;
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$direction = ($player !== null ? $player->getDirection() : 0) & 0x03;
-		$this->meta = $this->getVariant() | $direction;
-		return $this->getLevel()->setBlock($blockReplace, $this, true, true);
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player !== null){
+			$this->facing = Facing::rotateY($player->getHorizontalFacing(), true);
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function tickFalling() : ?Block{
+		return null;
 	}
 }

src/pocketmine/block/Banner.php

@@ -0,0 +1,194 @@
+<?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;
+
+use Ds\Deque;
+use pocketmine\block\tile\Banner as TileBanner;
+use pocketmine\block\utils\BannerPattern;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\block\utils\DyeColor;
+use pocketmine\item\Banner as ItemBanner;
+use pocketmine\item\Item;
+use pocketmine\item\ItemFactory;
+use pocketmine\item\ItemIds;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\utils\Utils;
+use pocketmine\world\BlockTransaction;
+use function assert;
+use function floor;
+
+class Banner extends Transparent{
+	/** @var BlockIdentifierFlattened */
+	protected $idInfo;
+
+	//TODO: conditionally useless properties, find a way to fix
+
+	/** @var int */
+	protected $rotation = 0;
+
+	/** @var int */
+	protected $facing = Facing::UP;
+
+	/** @var DyeColor */
+	protected $baseColor;
+
+	/** @var Deque|BannerPattern[] */
+	protected $patterns;
+
+	public function __construct(BlockIdentifierFlattened $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(1.0, BlockToolType::AXE));
+		$this->baseColor = DyeColor::BLACK();
+		$this->patterns = new Deque();
+	}
+
+	public function __clone(){
+		$this->patterns = $this->patterns->map(Utils::cloneCallback());
+	}
+
+	public function getId() : int{
+		return $this->facing === Facing::UP ? parent::getId() : $this->idInfo->getSecondId();
+	}
+
+	protected function writeStateToMeta() : int{
+		if($this->facing === Facing::UP){
+			return $this->rotation;
+		}
+		return BlockDataSerializer::writeHorizontalFacing($this->facing);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		if($id === $this->idInfo->getSecondId()){
+			$this->facing = BlockDataSerializer::readHorizontalFacing($stateMeta);
+		}else{
+			$this->facing = Facing::UP;
+			$this->rotation = $stateMeta;
+		}
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function readStateFromWorld() : void{
+		parent::readStateFromWorld();
+		$tile = $this->world->getTile($this);
+		if($tile instanceof TileBanner){
+			$this->baseColor = $tile->getBaseColor();
+			$this->setPatterns($tile->getPatterns());
+		}
+	}
+
+	public function writeStateToWorld() : void{
+		parent::writeStateToWorld();
+		$tile = $this->world->getTile($this);
+		assert($tile instanceof TileBanner);
+		$tile->setBaseColor($this->baseColor);
+		$tile->setPatterns($this->patterns);
+	}
+
+	public function isSolid() : bool{
+		return false;
+	}
+
+	/**
+	 * TODO: interface method? this is only the BASE colour...
+	 * @return DyeColor
+	 */
+	public function getColor() : DyeColor{
+		return $this->baseColor;
+	}
+
+	/**
+	 * @return Deque|BannerPattern[]
+	 */
+	public function getPatterns() : Deque{
+		return $this->patterns;
+	}
+
+	/**
+	 * @param Deque|BannerPattern[] $patterns
+	 */
+	public function setPatterns(Deque $patterns) : void{
+		$checked = $patterns->filter(function($v){ return $v instanceof BannerPattern; });
+		if($checked->count() !== $patterns->count()){
+			throw new \TypeError("Deque must only contain " . BannerPattern::class . " objects");
+		}
+		$this->patterns = $checked;
+	}
+
+	protected function recalculateBoundingBox() : ?AxisAlignedBB{
+		return null;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($item instanceof ItemBanner){
+			$this->baseColor = $item->getColor();
+			$this->setPatterns($item->getPatterns());
+		}
+		if($face !== Facing::DOWN){
+			$this->facing = $face;
+			if($face === Facing::UP){
+				$this->rotation = $player !== null ? ((int) floor((($player->yaw + 180) * 16 / 360) + 0.5)) & 0x0f : 0;
+			}
+
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+		}
+
+		return false;
+	}
+
+	public function onNearbyBlockChange() : void{
+		if($this->getSide(Facing::opposite($this->facing))->getId() === BlockLegacyIds::AIR){
+			$this->getWorld()->useBreakOn($this);
+		}
+	}
+
+	public function asItem() : Item{
+		return ItemFactory::get(ItemIds::BANNER, $this->baseColor->getInvertedMagicNumber());
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		$drop = $this->asItem();
+		if($drop instanceof ItemBanner and !$this->patterns->isEmpty()){
+			$drop->setPatterns($this->patterns);
+		}
+
+		return [$drop];
+	}
+
+	public function getPickedItem(bool $addUserData = false) : Item{
+		$result = $this->asItem();
+		if($addUserData and $result instanceof ItemBanner and !$this->patterns->isEmpty()){
+			$result->setPatterns($this->patterns);
+		}
+		return $result;
+	}
+
+	public function isAffectedBySilkTouch() : bool{
+		return false;
+	}
+}

src/pocketmine/block/BaseRail.php

@@ -23,9 +23,12 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\InvalidBlockStateException;
 use pocketmine\item\Item;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 use function array_map;
 use function array_reverse;
 use function array_search;
@@ -36,69 +39,76 @@ use function in_array;
 
 abstract class BaseRail extends Flowable{
 
-	public const STRAIGHT_NORTH_SOUTH = 0;
-	public const STRAIGHT_EAST_WEST = 1;
-	public const ASCENDING_EAST = 2;
-	public const ASCENDING_WEST = 3;
-	public const ASCENDING_NORTH = 4;
-	public const ASCENDING_SOUTH = 5;
-
-	private const ASCENDING_SIDES = [
-		self::ASCENDING_NORTH => Vector3::SIDE_NORTH,
-		self::ASCENDING_EAST => Vector3::SIDE_EAST,
-		self::ASCENDING_SOUTH => Vector3::SIDE_SOUTH,
-		self::ASCENDING_WEST => Vector3::SIDE_WEST
-	];
-
 	protected const FLAG_ASCEND = 1 << 24; //used to indicate direction-up
 
 	protected const CONNECTIONS = [
 		//straights
-		self::STRAIGHT_NORTH_SOUTH => [
-			Vector3::SIDE_NORTH,
-			Vector3::SIDE_SOUTH
+		BlockLegacyMetadata::RAIL_STRAIGHT_NORTH_SOUTH => [
+			Facing::NORTH,
+			Facing::SOUTH
 		],
-		self::STRAIGHT_EAST_WEST => [
-			Vector3::SIDE_EAST,
-			Vector3::SIDE_WEST
+		BlockLegacyMetadata::RAIL_STRAIGHT_EAST_WEST => [
+			Facing::EAST,
+			Facing::WEST
 		],
 
 		//ascending
-		self::ASCENDING_EAST => [
-			Vector3::SIDE_WEST,
-			Vector3::SIDE_EAST | self::FLAG_ASCEND
+		BlockLegacyMetadata::RAIL_ASCENDING_EAST => [
+			Facing::WEST,
+			Facing::EAST | self::FLAG_ASCEND
 		],
-		self::ASCENDING_WEST => [
-			Vector3::SIDE_EAST,
-			Vector3::SIDE_WEST | self::FLAG_ASCEND
+		BlockLegacyMetadata::RAIL_ASCENDING_WEST => [
+			Facing::EAST,
+			Facing::WEST | self::FLAG_ASCEND
 		],
-		self::ASCENDING_NORTH => [
-			Vector3::SIDE_SOUTH,
-			Vector3::SIDE_NORTH | self::FLAG_ASCEND
+		BlockLegacyMetadata::RAIL_ASCENDING_NORTH => [
+			Facing::SOUTH,
+			Facing::NORTH | self::FLAG_ASCEND
 		],
-		self::ASCENDING_SOUTH => [
-			Vector3::SIDE_NORTH,
-			Vector3::SIDE_SOUTH | self::FLAG_ASCEND
+		BlockLegacyMetadata::RAIL_ASCENDING_SOUTH => [
+			Facing::NORTH,
+			Facing::SOUTH | self::FLAG_ASCEND
 		]
 	];
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	/** @var int[] */
+	protected $connections = [];
+
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.7));
 	}
 
-	public function getHardness() : float{
-		return 0.7;
+	protected function writeStateToMeta() : int{
+		if(empty($this->connections)){
+			return BlockLegacyMetadata::RAIL_STRAIGHT_NORTH_SOUTH;
+		}
+		return $this->getMetaForState($this->connections);
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		if(!$blockReplace->getSide(Vector3::SIDE_DOWN)->isTransparent() and $this->getLevel()->setBlock($blockReplace, $this, true, true)){
-			$this->tryReconnect();
-			return true;
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$connections = $this->getConnectionsFromMeta($stateMeta);
+		if($connections === null){
+			throw new InvalidBlockStateException("Invalid rail type meta $stateMeta");
+		}
+		$this->connections = $connections;
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$blockReplace->getSide(Facing::DOWN)->isTransparent()){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
 		return false;
 	}
 
+	public function onPostPlace() : void{
+		$this->tryReconnect();
+	}
+
 	protected static function searchState(array $connections, array $lookup) : int{
 		$meta = array_search($connections, $lookup, true);
 		if($meta === false){
@@ -127,9 +137,11 @@ abstract class BaseRail extends Flowable{
 	/**
 	 * Returns the connection directions of this rail (depending on the current block state)
 	 *
+	 * @param int $meta
+	 *
 	 * @return int[]
 	 */
-	abstract protected function getConnectionsForState() : array;
+	abstract protected function getConnectionsFromMeta(int $meta) : ?array;
 
 	/**
 	 * Returns all the directions this rail is already connected in.
@@ -141,21 +153,21 @@ abstract class BaseRail extends Flowable{
 		$connections = [];
 
 		/** @var int $connection */
-		foreach($this->getConnectionsForState() as $connection){
+		foreach($this->connections as $connection){
 			$other = $this->getSide($connection & ~self::FLAG_ASCEND);
-			$otherConnection = Vector3::getOppositeSide($connection & ~self::FLAG_ASCEND);
+			$otherConnection = Facing::opposite($connection & ~self::FLAG_ASCEND);
 
 			if(($connection & self::FLAG_ASCEND) !== 0){
-				$other = $other->getSide(Vector3::SIDE_UP);
+				$other = $other->getSide(Facing::UP);
 
 			}elseif(!($other instanceof BaseRail)){ //check for rail sloping up to meet this one
-				$other = $other->getSide(Vector3::SIDE_DOWN);
+				$other = $other->getSide(Facing::DOWN);
 				$otherConnection |= self::FLAG_ASCEND;
 			}
 
 			if(
 				$other instanceof BaseRail and
-				in_array($otherConnection, $other->getConnectionsForState(), true)
+				in_array($otherConnection, $other->connections, true)
 			){
 				$connections[] = $connection;
 			}
@@ -169,10 +181,10 @@ abstract class BaseRail extends Flowable{
 			case 0:
 				//No constraints, can connect in any direction
 				$possible = [
-					Vector3::SIDE_NORTH => true,
-					Vector3::SIDE_SOUTH => true,
-					Vector3::SIDE_WEST => true,
-					Vector3::SIDE_EAST => true
+					Facing::NORTH => true,
+					Facing::SOUTH => true,
+					Facing::WEST => true,
+					Facing::EAST => true
 				];
 				foreach($possible as $p => $_){
 					$possible[$p | self::FLAG_ASCEND] = true;
@@ -189,7 +201,7 @@ abstract class BaseRail extends Flowable{
 	}
 
 	protected function getPossibleConnectionDirectionsOneConstraint(int $constraint) : array{
-		$opposite = Vector3::getOppositeSide($constraint & ~self::FLAG_ASCEND);
+		$opposite = Facing::opposite($constraint & ~self::FLAG_ASCEND);
 
 		$possible = [$opposite => true];
 
@@ -210,15 +222,15 @@ abstract class BaseRail extends Flowable{
 			$continue = false;
 
 			foreach($possible as $thisSide => $_){
-				$otherSide = Vector3::getOppositeSide($thisSide & ~self::FLAG_ASCEND);
+				$otherSide = Facing::opposite($thisSide & ~self::FLAG_ASCEND);
 
 				$other = $this->getSide($thisSide & ~self::FLAG_ASCEND);
 
 				if(($thisSide & self::FLAG_ASCEND) !== 0){
-					$other = $other->getSide(Vector3::SIDE_UP);
+					$other = $other->getSide(Facing::UP);
 
 				}elseif(!($other instanceof BaseRail)){ //check if other rails can slope up to meet this one
-					$other = $other->getSide(Vector3::SIDE_DOWN);
+					$other = $other->getSide(Facing::DOWN);
 					$otherSide |= self::FLAG_ASCEND;
 				}
 
@@ -231,7 +243,8 @@ abstract class BaseRail extends Flowable{
 
 				if(isset($otherPossible[$otherSide])){
 					$otherConnections[] = $otherSide;
-					$other->updateState($otherConnections);
+					$other->setConnections($otherConnections);
+					$other->world->setBlock($other, $other);
 
 					$changed = true;
 					$thisConnections[] = $thisSide;
@@ -243,31 +256,31 @@ abstract class BaseRail extends Flowable{
 		}while($continue);
 
 		if($changed){
-			$this->updateState($thisConnections);
+			$this->setConnections($thisConnections);
+			$this->world->setBlock($this, $this);
 		}
 	}
 
-	private function updateState(array $connections) : void{
+	private function setConnections(array $connections) : void{
 		if(count($connections) === 1){
-			$connections[] = Vector3::getOppositeSide($connections[0] & ~self::FLAG_ASCEND);
+			$connections[] = Facing::opposite($connections[0] & ~self::FLAG_ASCEND);
 		}elseif(count($connections) !== 2){
 			throw new \InvalidArgumentException("Expected exactly 2 connections, got " . count($connections));
 		}
 
-		$this->meta = $this->getMetaForState($connections);
-		$this->level->setBlock($this, $this, false, false); //avoid recursion
+		$this->connections = $connections;
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent() or (
-			isset(self::ASCENDING_SIDES[$this->meta & 0x07]) and
-			$this->getSide(self::ASCENDING_SIDES[$this->meta & 0x07])->isTransparent()
-		)){
-			$this->getLevel()->useBreakOn($this);
+		if($this->getSide(Facing::DOWN)->isTransparent()){
+			$this->world->useBreakOn($this);
+		}else{
+			foreach($this->connections as $connection){
+				if(($connection & self::FLAG_ASCEND) !== 0 and $this->getSide($connection & ~self::FLAG_ASCEND)->isTransparent()){
+					$this->world->useBreakOn($this);
+					break;
+				}
+			}
 		}
 	}
-
-	public function getVariantBitmask() : int{
-		return 0;
-	}
 }

src/pocketmine/block/Bed.php

@@ -23,118 +23,116 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\tile\Bed as TileBed;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\block\utils\DyeColor;
+use pocketmine\item\Bed as ItemBed;
 use pocketmine\item\Item;
 use pocketmine\item\ItemFactory;
 use pocketmine\lang\TranslationContainer;
-use pocketmine\level\Level;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
-use pocketmine\tile\Bed as TileBed;
-use pocketmine\tile\Tile;
+use pocketmine\player\Player;
 use pocketmine\utils\TextFormat;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\World;
 
 class Bed extends Transparent{
-	public const BITFLAG_OCCUPIED = 0x04;
-	public const BITFLAG_HEAD = 0x08;
 
-	protected $id = self::BED_BLOCK;
+	/** @var int */
+	protected $facing = Facing::NORTH;
+	/** @var bool */
+	protected $occupied = false;
+	/** @var bool */
+	protected $head = false;
+	/** @var DyeColor */
+	protected $color;
 
-	protected $itemId = Item::BED;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.2));
+		$this->color = DyeColor::RED();
 	}
 
-	public function getHardness() : float{
-		return 0.2;
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeLegacyHorizontalFacing($this->facing) |
+			($this->occupied ? BlockLegacyMetadata::BED_FLAG_OCCUPIED : 0) |
+			($this->head ? BlockLegacyMetadata::BED_FLAG_HEAD : 0);
 	}
 
-	public function getName() : string{
-		return "Bed Block";
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03);
+		$this->occupied = ($stateMeta & BlockLegacyMetadata::BED_FLAG_OCCUPIED) !== 0;
+		$this->head = ($stateMeta & BlockLegacyMetadata::BED_FLAG_HEAD) !== 0;
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function readStateFromWorld() : void{
+		parent::readStateFromWorld();
+		//read extra state information from the tile - this is an ugly hack
+		$tile = $this->world->getTile($this);
+		if($tile instanceof TileBed){
+			$this->color = $tile->getColor();
+		}
+	}
+
+	public function writeStateToWorld() : void{
+		parent::writeStateToWorld();
+		//extra block properties storage hack
+		$tile = $this->world->getTile($this);
+		if($tile instanceof TileBed){
+			$tile->setColor($this->color);
+		}
 	}
 
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-		return new AxisAlignedBB(
-			$this->x,
-			$this->y,
-			$this->z,
-			$this->x + 1,
-			$this->y + 0.5625,
-			$this->z + 1
-		);
+		return AxisAlignedBB::one()->trim(Facing::UP, 7 / 16);
 	}
 
 	public function isHeadPart() : bool{
-		return ($this->meta & self::BITFLAG_HEAD) !== 0;
+		return $this->head;
 	}
 
 	/**
 	 * @return bool
 	 */
 	public function isOccupied() : bool{
-		return ($this->meta & self::BITFLAG_OCCUPIED) !== 0;
+		return $this->occupied;
 	}
 
-	public function setOccupied(bool $occupied = true){
-		if($occupied){
-			$this->meta |= self::BITFLAG_OCCUPIED;
-		}else{
-			$this->meta &= ~self::BITFLAG_OCCUPIED;
-		}
+	public function setOccupied(bool $occupied = true) : void{
+		$this->occupied = $occupied;
+		$this->world->setBlock($this, $this, false);
 
-		$this->getLevel()->setBlock($this, $this, false, false);
-
-		if(($other = $this->getOtherHalf()) !== null and $other->isOccupied() !== $occupied){
-			$other->setOccupied($occupied);
+		if(($other = $this->getOtherHalf()) !== null){
+			$other->occupied = $occupied;
+			$this->world->setBlock($other, $other, false);
 		}
 	}
 
 	/**
-	 * @param int  $meta
-	 * @param bool $isHead
-	 *
 	 * @return int
 	 */
-	public static function getOtherHalfSide(int $meta, bool $isHead = false) : int{
-		$rotation = $meta & 0x03;
-		$side = -1;
-
-		switch($rotation){
-			case 0x00: //South
-				$side = Vector3::SIDE_SOUTH;
-				break;
-			case 0x01: //West
-				$side = Vector3::SIDE_WEST;
-				break;
-			case 0x02: //North
-				$side = Vector3::SIDE_NORTH;
-				break;
-			case 0x03: //East
-				$side = Vector3::SIDE_EAST;
-				break;
-		}
-
-		if($isHead){
-			$side = Vector3::getOppositeSide($side);
-		}
-
-		return $side;
+	private function getOtherHalfSide() : int{
+		return $this->head ? Facing::opposite($this->facing) : $this->facing;
 	}
 
 	/**
 	 * @return Bed|null
 	 */
 	public function getOtherHalf() : ?Bed{
-		$other = $this->getSide(self::getOtherHalfSide($this->meta, $this->isHeadPart()));
-		if($other instanceof Bed and $other->getId() === $this->getId() and $other->isHeadPart() !== $this->isHeadPart() and (($other->getDamage() & 0x03) === ($this->getDamage() & 0x03))){
+		$other = $this->getSide($this->getOtherHalfSide());
+		if($other instanceof Bed and $other->head !== $this->head and $other->facing === $this->facing){
 			return $other;
 		}
 
 		return null;
 	}
 
-	public function onActivate(Item $item, Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player !== null){
 			$other = $this->getOtherHalf();
 			if($other === null){
@@ -146,9 +144,9 @@ class Bed extends Transparent{
 				return true;
 			}
 
-			$time = $this->getLevel()->getTime() % Level::TIME_FULL;
+			$time = $this->getWorld()->getTimeOfDay();
 
-			$isNight = ($time >= Level::TIME_NIGHT and $time < Level::TIME_SUNRISE);
+			$isNight = ($time >= World::TIME_NIGHT and $time < World::TIME_SUNRISE);
 
 			if(!$isNight){
 				$player->sendMessage(new TranslationContainer(TextFormat::GRAY . "%tile.bed.noSleep"));
@@ -171,18 +169,19 @@ class Bed extends Transparent{
 
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$down = $this->getSide(Vector3::SIDE_DOWN);
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($item instanceof ItemBed){ //TODO: the item should do this
+			$this->color = $item->getColor();
+		}
+		$down = $this->getSide(Facing::DOWN);
 		if(!$down->isTransparent()){
-			$meta = (($player instanceof Player ? $player->getDirection() : 0) - 1) & 0x03;
-			$next = $this->getSide(self::getOtherHalfSide($meta));
-			if($next->canBeReplaced() and !$next->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-				$this->getLevel()->setBlock($blockReplace, BlockFactory::get($this->id, $meta), true, true);
-				$this->getLevel()->setBlock($next, BlockFactory::get($this->id, $meta | self::BITFLAG_HEAD), true, true);
-
-				Tile::createTile(Tile::BED, $this->getLevel(), TileBed::createNBT($this, $face, $item, $player));
-				Tile::createTile(Tile::BED, $this->getLevel(), TileBed::createNBT($next, $face, $item, $player));
+			$this->facing = $player !== null ? $player->getHorizontalFacing() : Facing::NORTH;
 
+			$next = $this->getSide($this->getOtherHalfSide());
+			if($next->canBeReplaced() and !$next->getSide(Facing::DOWN)->isTransparent()){
+				$nextState = clone $this;
+				$nextState->head = true;
+				$tx->addBlock($blockReplace, $this)->addBlock($next, $nextState);
 				return true;
 			}
 		}
@@ -190,29 +189,16 @@ class Bed extends Transparent{
 		return false;
 	}
 
-	public function getDropsForCompatibleTool(Item $item) : array{
-		if($this->isHeadPart()){
-			return [$this->getItem()];
+	public function getDrops(Item $item) : array{
+		if($this->head){
+			return parent::getDrops($item);
 		}
 
 		return [];
 	}
 
-	public function getPickedItem() : Item{
-		return $this->getItem();
-	}
-
-	private function getItem() : Item{
-		$tile = $this->getLevel()->getTile($this);
-		if($tile instanceof TileBed){
-			return ItemFactory::get($this->getItemId(), $tile->getColor());
-		}
-
-		return ItemFactory::get($this->getItemId(), 14); //Red
-	}
-
-	public function isAffectedBySilkTouch() : bool{
-		return false;
+	public function asItem() : Item{
+		return ItemFactory::get($this->idInfo->getItemId(), $this->color->getMagicNumber());
 	}
 
 	public function getAffectedBlocks() : array{

src/pocketmine/block/Bedrock.php

@@ -23,29 +23,28 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\item\Item;
+class Bedrock extends Opaque{
 
-class Bedrock extends Solid{
+	/** @var bool */
+	private $burnsForever = false;
 
-	protected $id = self::BEDROCK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? BlockBreakInfo::indestructible());
 	}
 
-	public function getName() : string{
-		return "Bedrock";
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->burnsForever = ($stateMeta & BlockLegacyMetadata::BEDROCK_FLAG_INFINIBURN) !== 0;
 	}
 
-	public function getHardness() : float{
-		return -1;
+	protected function writeStateToMeta() : int{
+		return $this->burnsForever ? BlockLegacyMetadata::BEDROCK_FLAG_INFINIBURN : 0;
 	}
 
-	public function getBlastResistance() : float{
-		return 18000000;
+	public function getStateBitmask() : int{
+		return 0b1;
 	}
 
-	public function isBreakable(Item $item) : bool{
-		return false;
+	public function burnsForever() : bool{
+		return $this->burnsForever;
 	}
 }

src/pocketmine/block/Beetroot.php

@@ -24,35 +24,25 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
 use function mt_rand;
 
 class Beetroot extends Crops{
 
-	protected $id = self::BEETROOT_BLOCK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Beetroot Block";
-	}
-
 	public function getDropsForCompatibleTool(Item $item) : array{
-		if($this->meta >= 0x07){
+		if($this->age >= 7){
 			return [
-				ItemFactory::get(Item::BEETROOT),
-				ItemFactory::get(Item::BEETROOT_SEEDS, 0, mt_rand(0, 3))
+				VanillaItems::BEETROOT(),
+				VanillaItems::BEETROOT_SEEDS()->setCount(mt_rand(0, 3))
 			];
 		}
 
 		return [
-			ItemFactory::get(Item::BEETROOT_SEEDS)
+			VanillaItems::BEETROOT_SEEDS()
 		];
 	}
 
-	public function getPickedItem() : Item{
-		return ItemFactory::get(Item::BEETROOT_SEEDS);
+	public function getPickedItem(bool $addUserData = false) : Item{
+		return VanillaItems::BEETROOT_SEEDS();
 	}
 }

src/pocketmine/block/Block.php

@@ -26,91 +26,88 @@ declare(strict_types=1);
  */
 namespace pocketmine\block;
 
+use pocketmine\block\tile\Spawnable;
+use pocketmine\block\tile\Tile;
+use pocketmine\block\tile\TileFactory;
+use pocketmine\block\utils\InvalidBlockStateException;
 use pocketmine\entity\Entity;
 use pocketmine\item\enchantment\Enchantment;
 use pocketmine\item\Item;
 use pocketmine\item\ItemFactory;
-use pocketmine\level\Position;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\RayTraceResult;
 use pocketmine\math\Vector3;
-use pocketmine\metadata\Metadatable;
-use pocketmine\metadata\MetadataValue;
+use pocketmine\nbt\tag\CompoundTag;
 use pocketmine\network\mcpe\protocol\types\RuntimeBlockMapping;
-use pocketmine\Player;
-use pocketmine\plugin\Plugin;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\Position;
+use pocketmine\world\World;
 use function array_merge;
-use function get_class;
+use function assert;
+use function dechex;
 use const PHP_INT_MAX;
 
-class Block extends Position implements BlockIds, Metadatable{
+class Block extends Position{
 
-	/**
-	 * Returns a new Block instance with the specified ID, meta and position.
-	 *
-	 * This function redirects to {@link BlockFactory#get}.
-	 *
-	 * @param int           $id
-	 * @param int           $meta
-	 * @param Position|null $pos
-	 *
-	 * @return Block
-	 */
-	public static function get(int $id, int $meta = 0, Position $pos = null) : Block{
-		return BlockFactory::get($id, $meta, $pos);
-	}
+	/** @var BlockIdentifier */
+	protected $idInfo;
 
-	/** @var int */
-	protected $id;
-	/** @var int */
-	protected $meta = 0;
-	/** @var string|null */
+	/** @var string */
 	protected $fallbackName;
-	/** @var int|null */
-	protected $itemId;
+
+	/** @var BlockBreakInfo */
+	protected $breakInfo;
+
 
 	/** @var AxisAlignedBB */
 	protected $boundingBox = null;
-
-
 	/** @var AxisAlignedBB[]|null */
 	protected $collisionBoxes = null;
 
 	/**
-	 * @param int         $id     The block type's ID, 0-255
-	 * @param int         $meta   Meta value of the block type
-	 * @param string|null $name   English name of the block type (TODO: implement translations)
-	 * @param int         $itemId The item ID of the block type, used for block picking and dropping items.
+	 * @param BlockIdentifier $idInfo
+	 * @param string          $name English name of the block type (TODO: implement translations)
+	 * @param BlockBreakInfo  $breakInfo
 	 */
-	public function __construct(int $id, int $meta = 0, string $name = null, int $itemId = null){
-		$this->id = $id;
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo){
+		if(($idInfo->getVariant() & $this->getStateBitmask()) !== 0){
+			throw new \InvalidArgumentException("Variant 0x" . dechex($idInfo->getVariant()) . " collides with state bitmask 0x" . dechex($this->getStateBitmask()));
+		}
+		$this->idInfo = $idInfo;
 		$this->fallbackName = $name;
-		$this->itemId = $itemId;
+		$this->breakInfo = $breakInfo;
+	}
+
+	public function getIdInfo() : BlockIdentifier{
+		return $this->idInfo;
 	}
 
 	/**
 	 * @return string
 	 */
 	public function getName() : string{
-		return $this->fallbackName ?? "Unknown";
+		return $this->fallbackName;
 	}
 
 	/**
 	 * @return int
 	 */
-	final public function getId() : int{
-		return $this->id;
+	public function getId() : int{
+		return $this->idInfo->getBlockId();
 	}
 
 	/**
-	 * Returns the ID of the item form of the block.
-	 * Used for drops for blocks (some blocks such as doors have a different item ID).
-	 *
+	 * @internal
 	 * @return int
 	 */
-	public function getItemId() : int{
-		return $this->itemId ?? $this->getId();
+	public function getFullId() : int{
+		return ($this->getId() << 4) | $this->getMeta();
+	}
+
+	public function asItem() : Item{
+		return ItemFactory::get($this->idInfo->getItemId(), $this->idInfo->getVariant());
 	}
 
 	/**
@@ -118,48 +115,97 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * @return int
 	 */
 	public function getRuntimeId() : int{
-		return RuntimeBlockMapping::toStaticRuntimeId($this->getId(), $this->getDamage());
+		return RuntimeBlockMapping::toStaticRuntimeId($this->getId(), $this->getMeta());
 	}
 
 	/**
 	 * @return int
 	 */
-	final public function getDamage() : int{
-		return $this->meta;
+	public function getMeta() : int{
+		$stateMeta = $this->writeStateToMeta();
+		assert(($stateMeta & ~$this->getStateBitmask()) === 0);
+		return $this->idInfo->getVariant() | $stateMeta;
+	}
+
+
+	/**
+	 * Returns a bitmask used to extract state bits from block metadata.
+	 *
+	 * @return int
+	 */
+	public function getStateBitmask() : int{
+		return 0;
+	}
+
+	protected function writeStateToMeta() : int{
+		return 0;
 	}
 
 	/**
-	 * @param int $meta
+	 * @param int $id
+	 * @param int $stateMeta
+	 *
+	 * @throws InvalidBlockStateException
 	 */
-	final public function setDamage(int $meta) : void{
-		if($meta < 0 or $meta > 0xf){
-			throw new \InvalidArgumentException("Block damage values must be 0-15, not $meta");
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		//NOOP
+	}
+
+	/**
+	 * Called when this block is created, set, or has a neighbouring block update, to re-detect dynamic properties which
+	 * are not saved on the world.
+	 *
+	 * Clears any cached precomputed objects, such as bounding boxes. Remove any outdated precomputed things such as
+	 * AABBs and force recalculation.
+	 */
+	public function readStateFromWorld() : void{
+		$this->boundingBox = null;
+		$this->collisionBoxes = null;
+	}
+
+	public function writeStateToWorld() : void{
+		$this->world->getChunkAtPosition($this)->setFullBlock($this->x & 0xf, $this->y, $this->z & 0xf, $this->getFullId());
+
+		$tileType = $this->idInfo->getTileClass();
+		$oldTile = $this->world->getTile($this);
+		if($oldTile !== null){
+			if($tileType === null or !($oldTile instanceof $tileType)){
+				$oldTile->close();
+				$oldTile = null;
+			}elseif($oldTile instanceof Spawnable){
+				$oldTile->setDirty(); //destroy old network cache
+			}
+		}
+		if($oldTile === null and $tileType !== null){
+			$this->world->addTile(TileFactory::create($tileType, $this->world, $this->asVector3()));
 		}
-		$this->meta = $meta;
 	}
 
 	/**
-	 * Bitmask to use to remove superfluous information from block meta when getting its item form or name.
-	 * This defaults to -1 (don't remove any data). Used to remove rotation data and bitflags from block drops.
+	 * Returns whether the given block has an equivalent type to this one. This compares base legacy ID and variant.
 	 *
-	 * If your block should not have any meta value when it's dropped as an item, override this to return 0 in
-	 * descendent classes.
+	 * Note: This ignores additional IDs used to represent additional states. This means that, for example, a lit
+	 * furnace and unlit furnace are considered the same type.
 	 *
-	 * @return int
+	 * @param Block $other
+	 *
+	 * @return bool
 	 */
-	public function getVariantBitmask() : int{
-		return -1;
+	public function isSameType(Block $other) : bool{
+		return $this->idInfo->getBlockId() === $other->idInfo->getBlockId() and $this->idInfo->getVariant() === $other->idInfo->getVariant();
 	}
 
 	/**
-	 * Returns the block meta, stripped of non-variant flags.
-	 * @return int
+	 * Returns whether the given block has the same type and properties as this block.
+	 *
+	 * @param Block $other
+	 *
+	 * @return bool
 	 */
-	public function getVariant() : int{
-		return $this->meta & $this->getVariantBitmask();
+	public function isSameState(Block $other) : bool{
+		return $this->isSameType($other) and $this->writeStateToMeta() === $other->writeStateToMeta();
 	}
 
-
 	/**
 	 * AKA: Block->isPlaceable
 	 * @return bool
@@ -182,73 +228,32 @@ class Block extends Position implements BlockIds, Metadatable{
 	/**
 	 * Places the Block, using block space and block target, and side. Returns if the block has been placed.
 	 *
-	 * @param Item        $item
-	 * @param Block       $blockReplace
-	 * @param Block       $blockClicked
-	 * @param int         $face
-	 * @param Vector3     $clickVector
-	 * @param Player|null $player
+	 * @param BlockTransaction $tx
+	 * @param Item             $item
+	 * @param Block            $blockReplace
+	 * @param Block            $blockClicked
+	 * @param int              $face
+	 * @param Vector3          $clickVector
+	 * @param Player|null      $player
 	 *
 	 * @return bool
 	 */
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		return $this->getLevel()->setBlock($this, $this, true, true);
-	}
-
-	/**
-	 * Returns if the block can be broken with an specific Item
-	 *
-	 * @param Item $item
-	 *
-	 * @return bool
-	 */
-	public function isBreakable(Item $item) : bool{
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$tx->addBlock($blockReplace, $this);
 		return true;
 	}
 
-	/**
-	 * @return int
-	 */
-	public function getToolType() : int{
-		return BlockToolType::TYPE_NONE;
+	public function onPostPlace() : void{
+
 	}
 
 	/**
-	 * Returns the level of tool required to harvest this block (for normal blocks). When the tool type matches the
-	 * block's required tool type, the tool must have a harvest level greater than or equal to this value to be able to
-	 * successfully harvest the block.
+	 * Returns an object containing information about the destruction requirements of this block.
 	 *
-	 * If the block requires a specific minimum tier of tiered tool, the minimum tier required should be returned.
-	 * Otherwise, 1 should be returned if a tool is required, 0 if not.
-	 *
-	 * @see Item::getBlockToolHarvestLevel()
-	 *
-	 * @return int
+	 * @return BlockBreakInfo
 	 */
-	public function getToolHarvestLevel() : int{
-		return 0;
-	}
-
-	/**
-	 * Returns whether the specified item is the proper tool to use for breaking this block. This checks tool type and
-	 * harvest level requirement.
-	 *
-	 * In most cases this is also used to determine whether block drops should be created or not, except in some
-	 * special cases such as vines.
-	 *
-	 * @param Item $tool
-	 *
-	 * @return bool
-	 */
-	public function isCompatibleWithTool(Item $tool) : bool{
-		if($this->getHardness() < 0){
-			return false;
-		}
-
-		$toolType = $this->getToolType();
-		$harvestLevel = $this->getToolHarvestLevel();
-		return $toolType === BlockToolType::TYPE_NONE or $harvestLevel === 0 or (
-			($toolType & $tool->getBlockToolType()) !== 0 and $tool->getBlockToolHarvestLevel() >= $harvestLevel);
+	public function getBreakInfo() : BlockBreakInfo{
+		return $this->breakInfo;
 	}
 
 	/**
@@ -259,35 +264,12 @@ class Block extends Position implements BlockIds, Metadatable{
 	 *
 	 * @return bool
 	 */
-	public function onBreak(Item $item, Player $player = null) : bool{
-		return $this->getLevel()->setBlock($this, BlockFactory::get(Block::AIR), true, true);
-	}
-
-
-	/**
-	 * Returns the seconds that this block takes to be broken using an specific Item
-	 *
-	 * @param Item $item
-	 *
-	 * @return float
-	 * @throws \InvalidArgumentException if the item efficiency is not a positive number
-	 */
-	public function getBreakTime(Item $item) : float{
-		$base = $this->getHardness();
-		if($this->isCompatibleWithTool($item)){
-			$base *= 1.5;
-		}else{
-			$base *= 5;
+	public function onBreak(Item $item, ?Player $player = null) : bool{
+		if(($t = $this->world->getTile($this)) !== null){
+			$t->onBlockDestroyed();
 		}
-
-		$efficiency = $item->getMiningEfficiency($this);
-		if($efficiency <= 0){
-			throw new \InvalidArgumentException(get_class($item) . " has invalid mining efficiency: expected >= 0, got $efficiency");
-		}
-
-		$base /= $efficiency;
-
-		return $base;
+		$this->getWorld()->setBlock($this, VanillaBlocks::AIR());
+		return true;
 	}
 
 	/**
@@ -315,38 +297,38 @@ class Block extends Position implements BlockIds, Metadatable{
 	}
 
 	/**
-	 * Called when this block is updated by the delayed blockupdate scheduler in the level.
+	 * Called when this block is updated by the delayed blockupdate scheduler in the world.
 	 */
 	public function onScheduledUpdate() : void{
 
 	}
 
 	/**
-	 * Do actions when activated by Item. Returns if it has done anything
+	 * Do actions when interacted by Item. Returns if it has done anything
 	 *
 	 * @param Item        $item
+	 * @param int         $face
+	 * @param Vector3     $clickVector
 	 * @param Player|null $player
 	 *
 	 * @return bool
 	 */
-	public function onActivate(Item $item, Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		return false;
 	}
 
 	/**
-	 * Returns a base value used to compute block break times.
-	 * @return float
+	 * Called when this block is attacked (left-clicked). This is called when a player left-clicks the block to try and
+	 * start to break it in survival mode.
+	 *
+	 * @param Item        $item
+	 * @param int         $face
+	 * @param Player|null $player
+	 *
+	 * @return bool if an action took place, prevents starting to break the block if true.
 	 */
-	public function getHardness() : float{
-		return 10;
-	}
-
-	/**
-	 * Returns the block's resistance to explosions. Usually 5x hardness.
-	 * @return float
-	 */
-	public function getBlastResistance() : float{
-		return $this->getHardness() * 5;
+	public function onAttack(Item $item, int $face, ?Player $player = null) : bool{
+		return false;
 	}
 
 	/**
@@ -370,7 +352,7 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * @return int 0-15
 	 */
 	public function getLightFilter() : int{
-		return 15;
+		return $this->isTransparent() ? 0 : 15;
 	}
 
 	/**
@@ -409,10 +391,6 @@ class Block extends Position implements BlockIds, Metadatable{
 		return false;
 	}
 
-	public function canPassThrough() : bool{
-		return false;
-	}
-
 	/**
 	 * Returns whether entities can climb up this block.
 	 * @return bool
@@ -427,16 +405,18 @@ class Block extends Position implements BlockIds, Metadatable{
 	}
 
 	/**
-	 * Sets the block position to a new Position object
+	 * @internal
 	 *
-	 * @param Position $v
+	 * @param World $world
+	 * @param int   $x
+	 * @param int   $y
+	 * @param int   $z
 	 */
-	final public function position(Position $v) : void{
-		$this->x = (int) $v->x;
-		$this->y = (int) $v->y;
-		$this->z = (int) $v->z;
-		$this->level = $v->level;
-		$this->boundingBox = null;
+	final public function position(World $world, int $x, int $y, int $z) : void{
+		$this->x = $x;
+		$this->y = $y;
+		$this->z = $z;
+		$this->world = $world;
 	}
 
 	/**
@@ -447,8 +427,8 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * @return Item[]
 	 */
 	public function getDrops(Item $item) : array{
-		if($this->isCompatibleWithTool($item)){
-			if($this->isAffectedBySilkTouch() and $item->hasEnchantment(Enchantment::SILK_TOUCH)){
+		if($this->breakInfo->isToolCompatible($item)){
+			if($this->isAffectedBySilkTouch() and $item->hasEnchantment(Enchantment::SILK_TOUCH())){
 				return $this->getSilkTouchDrops($item);
 			}
 
@@ -466,9 +446,7 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * @return Item[]
 	 */
 	public function getDropsForCompatibleTool(Item $item) : array{
-		return [
-			ItemFactory::get($this->getItemId(), $this->getVariant())
-		];
+		return [$this->asItem()];
 	}
 
 	/**
@@ -479,9 +457,7 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * @return Item[]
 	 */
 	public function getSilkTouchDrops(Item $item) : array{
-		return [
-			ItemFactory::get($this->getItemId(), $this->getVariant())
-		];
+		return [$this->asItem()];
 	}
 
 	/**
@@ -492,7 +468,7 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * @return int
 	 */
 	public function getXpDropForTool(Item $item) : int{
-		if($item->hasEnchantment(Enchantment::SILK_TOUCH) or !$this->isCompatibleWithTool($item)){
+		if($item->hasEnchantment(Enchantment::SILK_TOUCH()) or !$this->breakInfo->isToolCompatible($item)){
 			return 0;
 		}
 
@@ -520,10 +496,24 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns the item that players will equip when middle-clicking on this block.
+	 *
+	 * @param bool $addUserData
+	 *
 	 * @return Item
 	 */
-	public function getPickedItem() : Item{
-		return ItemFactory::get($this->getItemId(), $this->getVariant());
+	public function getPickedItem(bool $addUserData = false) : Item{
+		$item = $this->asItem();
+		if($addUserData){
+			$tile = $this->world->getTile($this);
+			if($tile instanceof Tile){
+				$nbt = $tile->getCleanedNBT();
+				if($nbt instanceof CompoundTag){
+					$item->setCustomBlockData($nbt);
+					$item->setLore(["+(DATA)"]);
+				}
+			}
+		}
+		return $item;
 	}
 
 	/**
@@ -588,10 +578,10 @@ class Block extends Position implements BlockIds, Metadatable{
 	 */
 	public function getSide(int $side, int $step = 1){
 		if($this->isValid()){
-			return $this->getLevel()->getBlock(Vector3::getSide($side, $step));
+			return $this->getWorld()->getBlock(Vector3::getSide($side, $step));
 		}
 
-		return BlockFactory::get(Block::AIR, 0, Position::fromObject(Vector3::getSide($side, $step)));
+		throw new \InvalidStateException("Block does not have a valid world");
 	}
 
 	/**
@@ -601,10 +591,10 @@ class Block extends Position implements BlockIds, Metadatable{
 	 */
 	public function getHorizontalSides() : array{
 		return [
-			$this->getSide(Vector3::SIDE_NORTH),
-			$this->getSide(Vector3::SIDE_SOUTH),
-			$this->getSide(Vector3::SIDE_WEST),
-			$this->getSide(Vector3::SIDE_EAST)
+			$this->getSide(Facing::NORTH),
+			$this->getSide(Facing::SOUTH),
+			$this->getSide(Facing::WEST),
+			$this->getSide(Facing::EAST)
 		];
 	}
 
@@ -616,8 +606,8 @@ class Block extends Position implements BlockIds, Metadatable{
 	public function getAllSides() : array{
 		return array_merge(
 			[
-				$this->getSide(Vector3::SIDE_DOWN),
-				$this->getSide(Vector3::SIDE_UP)
+				$this->getSide(Facing::DOWN),
+				$this->getSide(Facing::UP)
 			],
 			$this->getHorizontalSides()
 		);
@@ -637,7 +627,7 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * @return string
 	 */
 	public function __toString(){
-		return "Block[" . $this->getName() . "] (" . $this->getId() . ":" . $this->getDamage() . ")";
+		return "Block[" . $this->getName() . "] (" . $this->getId() . ":" . $this->getMeta() . ")";
 	}
 
 	/**
@@ -658,9 +648,12 @@ class Block extends Position implements BlockIds, Metadatable{
 	}
 
 	/**
+	 * Called when an entity's bounding box clips inside this block's cell. Note that the entity may not be intersecting
+	 * with the collision box or bounding box.
+	 *
 	 * @param Entity $entity
 	 */
-	public function onEntityCollide(Entity $entity) : void{
+	public function onEntityInside(Entity $entity) : void{
 
 	}
 
@@ -670,6 +663,9 @@ class Block extends Position implements BlockIds, Metadatable{
 	public function getCollisionBoxes() : array{
 		if($this->collisionBoxes === null){
 			$this->collisionBoxes = $this->recalculateCollisionBoxes();
+			foreach($this->collisionBoxes as $bb){
+				$bb->offset($this->x, $this->y, $this->z);
+			}
 		}
 
 		return $this->collisionBoxes;
@@ -692,6 +688,9 @@ class Block extends Position implements BlockIds, Metadatable{
 	public function getBoundingBox() : ?AxisAlignedBB{
 		if($this->boundingBox === null){
 			$this->boundingBox = $this->recalculateBoundingBox();
+			if($this->boundingBox !== null){
+				$this->boundingBox->offset($this->x, $this->y, $this->z);
+			}
 		}
 		return $this->boundingBox;
 	}
@@ -700,23 +699,7 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * @return AxisAlignedBB|null
 	 */
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-		return new AxisAlignedBB(
-			$this->x,
-			$this->y,
-			$this->z,
-			$this->x + 1,
-			$this->y + 1,
-			$this->z + 1
-		);
-	}
-
-	/**
-	 * Clears any cached precomputed objects, such as bounding boxes. This is called on block neighbour update and when
-	 * the block is set into the world to remove any outdated precomputed things such as AABBs and force recalculation.
-	 */
-	public function clearCaches() : void{
-		$this->boundingBox = null;
-		$this->collisionBoxes = null;
+		return AxisAlignedBB::one();
 	}
 
 	/**
@@ -752,31 +735,15 @@ class Block extends Position implements BlockIds, Metadatable{
 		return $currentHit;
 	}
 
-	public function setMetadata(string $metadataKey, MetadataValue $newMetadataValue){
-		if($this->isValid()){
-			$this->level->getBlockMetadata()->setMetadata($this, $metadataKey, $newMetadataValue);
-		}
-	}
-
-	public function getMetadata(string $metadataKey){
-		if($this->isValid()){
-			return $this->level->getBlockMetadata()->getMetadata($this, $metadataKey);
-		}
-
-		return null;
-	}
-
-	public function hasMetadata(string $metadataKey) : bool{
-		if($this->isValid()){
-			return $this->level->getBlockMetadata()->hasMetadata($this, $metadataKey);
-		}
-
-		return false;
-	}
-
-	public function removeMetadata(string $metadataKey, Plugin $owningPlugin){
-		if($this->isValid()){
-			$this->level->getBlockMetadata()->removeMetadata($this, $metadataKey, $owningPlugin);
+	/**
+	 * @param self $self
+	 *
+	 * @return static
+	 */
+	public static function cast(self $self){
+		if(!($self instanceof static)){
+			throw new \TypeError("Cannot cast from " . self::class . " to " . static::class);
 		}
+		return $self;
 	}
 }

src/pocketmine/block/BlockBreakInfo.php

@@ -0,0 +1,165 @@
+<?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;
+
+use pocketmine\item\Item;
+use function get_class;
+
+class BlockBreakInfo{
+
+	/** @var float */
+	private $hardness;
+	/** @var float */
+	private $blastResistance;
+	/** @var int */
+	private $toolType;
+	/** @var int */
+	private $toolHarvestLevel;
+
+	/**
+	 * @param float      $hardness
+	 * @param int        $toolType
+	 * @param int        $toolHarvestLevel
+	 * @param float|null $blastResistance default 5x hardness
+	 */
+	public function __construct(float $hardness, int $toolType = BlockToolType::NONE, int $toolHarvestLevel = 0, ?float $blastResistance = null){
+		$this->hardness = $hardness;
+		$this->toolType = $toolType;
+		$this->toolHarvestLevel = $toolHarvestLevel;
+		$this->blastResistance = $blastResistance ?? $hardness * 5;
+	}
+
+	public static function instant(int $toolType = BlockToolType::NONE, int $toolHarvestLevel = 0) : self{
+		return new self(0.0, $toolType, $toolHarvestLevel, 0.0);
+	}
+
+	public static function indestructible(float $blastResistance = 18000000.0) : self{
+		return new self(-1.0, BlockToolType::NONE, 0, $blastResistance);
+	}
+
+	/**
+	 * Returns a base value used to compute block break times.
+	 *
+	 * @return float
+	 */
+	public function getHardness() : float{
+		return $this->hardness;
+	}
+
+	/**
+	 * Returns whether the block can be broken at all.
+	 *
+	 * @return bool
+	 */
+	public function isBreakable() : bool{
+		return $this->hardness >= 0;
+	}
+
+	/**
+	 * Returns whether this block can be instantly broken.
+	 *
+	 * @return bool
+	 */
+	public function breaksInstantly() : bool{
+		return $this->hardness == 0.0;
+	}
+
+	/**
+	 * Returns the block's resistance to explosions. Usually 5x hardness.
+	 *
+	 * @return float
+	 */
+	public function getBlastResistance() : float{
+		return $this->blastResistance;
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getToolType() : int{
+		return $this->toolType;
+	}
+
+	/**
+	 * Returns the level of tool required to harvest the block (for normal blocks). When the tool type matches the
+	 * block's required tool type, the tool must have a harvest level greater than or equal to this value to be able to
+	 * successfully harvest the block.
+	 *
+	 * If the block requires a specific minimum tier of tiered tool, the minimum tier required should be returned.
+	 * Otherwise, 1 should be returned if a tool is required, 0 if not.
+	 *
+	 * @see Item::getBlockToolHarvestLevel()
+	 *
+	 * @return int
+	 */
+	public function getToolHarvestLevel() : int{
+		return $this->toolHarvestLevel;
+	}
+
+	/**
+	 * Returns whether the specified item is the proper tool to use for breaking this block. This checks tool type and
+	 * harvest level requirement.
+	 *
+	 * In most cases this is also used to determine whether block drops should be created or not, except in some
+	 * special cases such as vines.
+	 *
+	 * @param Item $tool
+	 *
+	 * @return bool
+	 */
+	public function isToolCompatible(Item $tool) : bool{
+		if($this->hardness < 0){
+			return false;
+		}
+
+		return $this->toolType === BlockToolType::NONE or $this->toolHarvestLevel === 0 or (
+				($this->toolType & $tool->getBlockToolType()) !== 0 and $tool->getBlockToolHarvestLevel() >= $this->toolHarvestLevel);
+	}
+
+	/**
+	 * Returns the seconds that this block takes to be broken using an specific Item
+	 *
+	 * @param Item $item
+	 *
+	 * @return float
+	 * @throws \InvalidArgumentException if the item efficiency is not a positive number
+	 */
+	public function getBreakTime(Item $item) : float{
+		$base = $this->hardness;
+		if($this->isToolCompatible($item)){
+			$base *= 1.5;
+		}else{
+			$base *= 5;
+		}
+
+		$efficiency = $item->getMiningEfficiency(($this->toolType & $item->getBlockToolType()) !== 0);
+		if($efficiency <= 0){
+			throw new \InvalidArgumentException(get_class($item) . " has invalid mining efficiency: expected >= 0, got $efficiency");
+		}
+
+		$base /= $efficiency;
+
+		return $base;
+	}
+}

src/pocketmine/block/BlockIdentifier.php

@@ -0,0 +1,78 @@
+<?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;
+
+class BlockIdentifier{
+
+	/** @var int */
+	private $blockId;
+	/** @var int */
+	private $variant;
+	/** @var int|null */
+	private $itemId;
+	/** @var string|null */
+	private $tileClass;
+
+	public function __construct(int $blockId, int $variant = 0, ?int $itemId = null, ?string $tileClass = null){
+		$this->blockId = $blockId;
+		$this->variant = $variant;
+		$this->itemId = $itemId;
+		$this->tileClass = $tileClass;
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getBlockId() : int{
+		return $this->blockId;
+	}
+
+	/**
+	 * @return int[]
+	 */
+	public function getAllBlockIds() : array{
+		return [$this->blockId];
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getVariant() : int{
+		return $this->variant;
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getItemId() : int{
+		return $this->itemId ?? ($this->blockId > 255 ? 255 - $this->blockId : $this->blockId);
+	}
+
+	/**
+	 * @return string|null
+	 */
+	public function getTileClass() : ?string{
+		return $this->tileClass;
+	}
+}

src/pocketmine/block/BlockIdentifierFlattened.php

@@ -21,31 +21,26 @@
 
 declare(strict_types=1);
 
-namespace pocketmine\event\player;
+namespace pocketmine\block;
 
-use pocketmine\event\Cancellable;
-use pocketmine\Player;
+class BlockIdentifierFlattened extends BlockIdentifier{
 
-/**
- * Called when a player does an animation
- */
-class PlayerAnimationEvent extends PlayerEvent implements Cancellable{
 	/** @var int */
-	private $animationType;
+	private $secondId;
 
-	/**
-	 * @param Player $player
-	 * @param int    $animation
-	 */
-	public function __construct(Player $player, int $animation){
-		$this->player = $player;
-		$this->animationType = $animation;
+	public function __construct(int $blockId, int $secondId, int $variant = 0, ?int $itemId = null, ?string $tileClass = null){
+		parent::__construct($blockId, $variant, $itemId, $tileClass);
+		$this->secondId = $secondId;
 	}
 
 	/**
 	 * @return int
 	 */
-	public function getAnimationType() : int{
-		return $this->animationType;
+	public function getSecondId() : int{
+		return $this->secondId;
+	}
+
+	public function getAllBlockIds() : array{
+		return [$this->getBlockId(), $this->getSecondId()];
 	}
 }

src/pocketmine/block/BlockLegacyIds.php

@@ -23,7 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-interface BlockIds{
+interface BlockLegacyIds{
 
 	public const AIR = 0;
 	public const STONE = 1;
@@ -42,7 +42,7 @@ interface BlockIds{
 	public const GOLD_ORE = 14;
 	public const IRON_ORE = 15;
 	public const COAL_ORE = 16;
-	public const LOG = 17, WOOD = 17;
+	public const LOG = 17;
 	public const LEAVES = 18;
 	public const SPONGE = 19;
 	public const GLASS = 20;
@@ -61,7 +61,7 @@ interface BlockIds{
 	public const PISTON = 33;
 	public const PISTONARMCOLLISION = 34, PISTON_ARM_COLLISION = 34;
 	public const WOOL = 35;
-
+	public const ELEMENT_0 = 36;
 	public const DANDELION = 37, YELLOW_FLOWER = 37;
 	public const POPPY = 38, RED_FLOWER = 38;
 	public const BROWN_MUSHROOM = 39;
@@ -187,11 +187,11 @@ interface BlockIds{
 	public const STAINED_CLAY = 159, STAINED_HARDENED_CLAY = 159, TERRACOTTA = 159;
 	public const STAINED_GLASS_PANE = 160;
 	public const LEAVES2 = 161;
-	public const LOG2 = 162, WOOD2 = 162;
+	public const LOG2 = 162;
 	public const ACACIA_STAIRS = 163;
 	public const DARK_OAK_STAIRS = 164;
 	public const SLIME = 165, SLIME_BLOCK = 165;
-
+	public const GLOW_STICK = 166;
 	public const IRON_TRAPDOOR = 167;
 	public const PRISMARINE = 168;
 	public const SEALANTERN = 169, SEA_LANTERN = 169;
@@ -215,7 +215,9 @@ interface BlockIds{
 	public const ACACIA_FENCE_GATE = 187;
 	public const REPEATING_COMMAND_BLOCK = 188;
 	public const CHAIN_COMMAND_BLOCK = 189;
-
+	public const HARD_GLASS_PANE = 190;
+	public const HARD_STAINED_GLASS_PANE = 191;
+	public const CHEMICAL_HEAT = 192;
 	public const SPRUCE_DOOR_BLOCK = 193;
 	public const BIRCH_DOOR_BLOCK = 194;
 	public const JUNGLE_DOOR_BLOCK = 195;
@@ -225,9 +227,9 @@ interface BlockIds{
 	public const FRAME_BLOCK = 199, ITEM_FRAME_BLOCK = 199;
 	public const CHORUS_FLOWER = 200;
 	public const PURPUR_BLOCK = 201;
-
+	public const COLORED_TORCH_RG = 202;
 	public const PURPUR_STAIRS = 203;
-
+	public const COLORED_TORCH_BP = 204;
 	public const UNDYED_SHULKER_BOX = 205;
 	public const END_BRICKS = 206;
 	public const FROSTED_ICE = 207;
@@ -259,7 +261,8 @@ interface BlockIds{
 	public const BLACK_GLAZED_TERRACOTTA = 235;
 	public const CONCRETE = 236;
 	public const CONCRETEPOWDER = 237, CONCRETE_POWDER = 237;
-
+	public const CHEMISTRY_TABLE = 238;
+	public const UNDERWATER_TORCH = 239;
 	public const CHORUS_PLANT = 240;
 	public const STAINED_GLASS = 241;
 
@@ -273,7 +276,222 @@ interface BlockIds{
 	public const MOVINGBLOCK = 250, MOVING_BLOCK = 250;
 	public const OBSERVER = 251;
 	public const STRUCTURE_BLOCK = 252;
-
+	public const HARD_GLASS = 253;
+	public const HARD_STAINED_GLASS = 254;
 	public const RESERVED6 = 255;
 
+	public const PRISMARINE_STAIRS = 257;
+	public const DARK_PRISMARINE_STAIRS = 258;
+	public const PRISMARINE_BRICKS_STAIRS = 259;
+	public const STRIPPED_SPRUCE_LOG = 260;
+	public const STRIPPED_BIRCH_LOG = 261;
+	public const STRIPPED_JUNGLE_LOG = 262;
+	public const STRIPPED_ACACIA_LOG = 263;
+	public const STRIPPED_DARK_OAK_LOG = 264;
+	public const STRIPPED_OAK_LOG = 265;
+	public const BLUE_ICE = 266;
+	public const ELEMENT_1 = 267;
+	public const ELEMENT_2 = 268;
+	public const ELEMENT_3 = 269;
+	public const ELEMENT_4 = 270;
+	public const ELEMENT_5 = 271;
+	public const ELEMENT_6 = 272;
+	public const ELEMENT_7 = 273;
+	public const ELEMENT_8 = 274;
+	public const ELEMENT_9 = 275;
+	public const ELEMENT_10 = 276;
+	public const ELEMENT_11 = 277;
+	public const ELEMENT_12 = 278;
+	public const ELEMENT_13 = 279;
+	public const ELEMENT_14 = 280;
+	public const ELEMENT_15 = 281;
+	public const ELEMENT_16 = 282;
+	public const ELEMENT_17 = 283;
+	public const ELEMENT_18 = 284;
+	public const ELEMENT_19 = 285;
+	public const ELEMENT_20 = 286;
+	public const ELEMENT_21 = 287;
+	public const ELEMENT_22 = 288;
+	public const ELEMENT_23 = 289;
+	public const ELEMENT_24 = 290;
+	public const ELEMENT_25 = 291;
+	public const ELEMENT_26 = 292;
+	public const ELEMENT_27 = 293;
+	public const ELEMENT_28 = 294;
+	public const ELEMENT_29 = 295;
+	public const ELEMENT_30 = 296;
+	public const ELEMENT_31 = 297;
+	public const ELEMENT_32 = 298;
+	public const ELEMENT_33 = 299;
+	public const ELEMENT_34 = 300;
+	public const ELEMENT_35 = 301;
+	public const ELEMENT_36 = 302;
+	public const ELEMENT_37 = 303;
+	public const ELEMENT_38 = 304;
+	public const ELEMENT_39 = 305;
+	public const ELEMENT_40 = 306;
+	public const ELEMENT_41 = 307;
+	public const ELEMENT_42 = 308;
+	public const ELEMENT_43 = 309;
+	public const ELEMENT_44 = 310;
+	public const ELEMENT_45 = 311;
+	public const ELEMENT_46 = 312;
+	public const ELEMENT_47 = 313;
+	public const ELEMENT_48 = 314;
+	public const ELEMENT_49 = 315;
+	public const ELEMENT_50 = 316;
+	public const ELEMENT_51 = 317;
+	public const ELEMENT_52 = 318;
+	public const ELEMENT_53 = 319;
+	public const ELEMENT_54 = 320;
+	public const ELEMENT_55 = 321;
+	public const ELEMENT_56 = 322;
+	public const ELEMENT_57 = 323;
+	public const ELEMENT_58 = 324;
+	public const ELEMENT_59 = 325;
+	public const ELEMENT_60 = 326;
+	public const ELEMENT_61 = 327;
+	public const ELEMENT_62 = 328;
+	public const ELEMENT_63 = 329;
+	public const ELEMENT_64 = 330;
+	public const ELEMENT_65 = 331;
+	public const ELEMENT_66 = 332;
+	public const ELEMENT_67 = 333;
+	public const ELEMENT_68 = 334;
+	public const ELEMENT_69 = 335;
+	public const ELEMENT_70 = 336;
+	public const ELEMENT_71 = 337;
+	public const ELEMENT_72 = 338;
+	public const ELEMENT_73 = 339;
+	public const ELEMENT_74 = 340;
+	public const ELEMENT_75 = 341;
+	public const ELEMENT_76 = 342;
+	public const ELEMENT_77 = 343;
+	public const ELEMENT_78 = 344;
+	public const ELEMENT_79 = 345;
+	public const ELEMENT_80 = 346;
+	public const ELEMENT_81 = 347;
+	public const ELEMENT_82 = 348;
+	public const ELEMENT_83 = 349;
+	public const ELEMENT_84 = 350;
+	public const ELEMENT_85 = 351;
+	public const ELEMENT_86 = 352;
+	public const ELEMENT_87 = 353;
+	public const ELEMENT_88 = 354;
+	public const ELEMENT_89 = 355;
+	public const ELEMENT_90 = 356;
+	public const ELEMENT_91 = 357;
+	public const ELEMENT_92 = 358;
+	public const ELEMENT_93 = 359;
+	public const ELEMENT_94 = 360;
+	public const ELEMENT_95 = 361;
+	public const ELEMENT_96 = 362;
+	public const ELEMENT_97 = 363;
+	public const ELEMENT_98 = 364;
+	public const ELEMENT_99 = 365;
+	public const ELEMENT_100 = 366;
+	public const ELEMENT_101 = 367;
+	public const ELEMENT_102 = 368;
+	public const ELEMENT_103 = 369;
+	public const ELEMENT_104 = 370;
+	public const ELEMENT_105 = 371;
+	public const ELEMENT_106 = 372;
+	public const ELEMENT_107 = 373;
+	public const ELEMENT_108 = 374;
+	public const ELEMENT_109 = 375;
+	public const ELEMENT_110 = 376;
+	public const ELEMENT_111 = 377;
+	public const ELEMENT_112 = 378;
+	public const ELEMENT_113 = 379;
+	public const ELEMENT_114 = 380;
+	public const ELEMENT_115 = 381;
+	public const ELEMENT_116 = 382;
+	public const ELEMENT_117 = 383;
+	public const ELEMENT_118 = 384;
+	public const SEAGRASS = 385;
+	public const CORAL = 386;
+	public const CORAL_BLOCK = 387;
+	public const CORAL_FAN = 388;
+	public const CORAL_FAN_DEAD = 389;
+	public const CORAL_FAN_HANG = 390;
+	public const CORAL_FAN_HANG2 = 391;
+	public const CORAL_FAN_HANG3 = 392;
+	public const KELP = 393;
+	public const DRIED_KELP_BLOCK = 394;
+	public const ACACIA_BUTTON = 395;
+	public const BIRCH_BUTTON = 396;
+	public const DARK_OAK_BUTTON = 397;
+	public const JUNGLE_BUTTON = 398;
+	public const SPRUCE_BUTTON = 399;
+	public const ACACIA_TRAPDOOR = 400;
+	public const BIRCH_TRAPDOOR = 401;
+	public const DARK_OAK_TRAPDOOR = 402;
+	public const JUNGLE_TRAPDOOR = 403;
+	public const SPRUCE_TRAPDOOR = 404;
+	public const ACACIA_PRESSURE_PLATE = 405;
+	public const BIRCH_PRESSURE_PLATE = 406;
+	public const DARK_OAK_PRESSURE_PLATE = 407;
+	public const JUNGLE_PRESSURE_PLATE = 408;
+	public const SPRUCE_PRESSURE_PLATE = 409;
+	public const CARVED_PUMPKIN = 410;
+	public const SEA_PICKLE = 411;
+	public const CONDUIT = 412;
+
+	public const TURTLE_EGG = 414;
+	public const BUBBLE_COLUMN = 415;
+	public const BARRIER = 416;
+	public const STONE_SLAB3 = 417;
+	public const BAMBOO = 418;
+	public const BAMBOO_SAPLING = 419;
+	public const SCAFFOLDING = 420;
+	public const STONE_SLAB4 = 421;
+	public const DOUBLE_STONE_SLAB3 = 422;
+	public const DOUBLE_STONE_SLAB4 = 423;
+	public const GRANITE_STAIRS = 424;
+	public const DIORITE_STAIRS = 425;
+	public const ANDESITE_STAIRS = 426;
+	public const POLISHED_GRANITE_STAIRS = 427;
+	public const POLISHED_DIORITE_STAIRS = 428;
+	public const POLISHED_ANDESITE_STAIRS = 429;
+	public const MOSSY_STONE_BRICK_STAIRS = 430;
+	public const SMOOTH_RED_SANDSTONE_STAIRS = 431;
+	public const SMOOTH_SANDSTONE_STAIRS = 432;
+	public const END_BRICK_STAIRS = 433;
+	public const MOSSY_COBBLESTONE_STAIRS = 434;
+	public const NORMAL_STONE_STAIRS = 435;
+	public const SPRUCE_STANDING_SIGN = 436;
+	public const SPRUCE_WALL_SIGN = 437;
+	public const SMOOTH_STONE = 438;
+	public const RED_NETHER_BRICK_STAIRS = 439;
+	public const SMOOTH_QUARTZ_STAIRS = 440;
+	public const BIRCH_STANDING_SIGN = 441;
+	public const BIRCH_WALL_SIGN = 442;
+	public const JUNGLE_STANDING_SIGN = 443;
+	public const JUNGLE_WALL_SIGN = 444;
+	public const ACACIA_STANDING_SIGN = 445;
+	public const ACACIA_WALL_SIGN = 446;
+	public const DARKOAK_STANDING_SIGN = 447;
+	public const DARKOAK_WALL_SIGN = 448;
+	public const LECTERN = 449;
+	public const GRINDSTONE = 450;
+	public const BLAST_FURNACE = 451;
+	public const STONECUTTER_BLOCK = 452;
+	public const SMOKER = 453;
+	public const LIT_SMOKER = 454;
+	public const CARTOGRAPHY_TABLE = 455;
+	public const FLETCHING_TABLE = 456;
+	public const SMITHING_TABLE = 457;
+	public const BARREL = 458;
+	public const LOOM = 459;
+
+	public const BELL = 461;
+	public const SWEET_BERRY_BUSH = 462;
+	public const LANTERN = 463;
+	public const CAMPFIRE = 464;
+	public const LAVA_CAULDRON = 465;
+	public const JIGSAW = 466;
+	public const WOOD = 467;
+	public const COMPOSTER = 468;
+	public const LIT_BLAST_FURNACE = 469;
+
 }

src/pocketmine/block/BlockLegacyMetadata.php

@@ -0,0 +1,240 @@
+<?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;
+
+/**
+ * Constants for legacy metadata for various blocks.
+ */
+interface BlockLegacyMetadata{
+
+	public const ANVIL_NORMAL = 0;
+	public const ANVIL_SLIGHTLY_DAMAGED = 4;
+	public const ANVIL_VERY_DAMAGED = 8;
+
+	public const BED_FLAG_HEAD = 0x08;
+	public const BED_FLAG_OCCUPIED = 0x04;
+
+	public const BEDROCK_FLAG_INFINIBURN = 0x01;
+
+	public const BREWING_STAND_FLAG_EAST = 0x01;
+	public const BREWING_STAND_FLAG_SOUTHWEST = 0x02;
+	public const BREWING_STAND_FLAG_NORTHWEST = 0x04;
+
+	public const BUTTON_FLAG_POWERED = 0x08;
+
+	public const COLORED_TORCH_BP_BLUE = 0;
+	public const COLORED_TORCH_BP_PURPLE = 8;
+	public const COLORED_TORCH_RG_RED = 0;
+	public const COLORED_TORCH_RG_GREEN = 8;
+
+	public const DIRT_NORMAL = 0;
+	public const DIRT_COARSE = 1;
+
+	public const DOOR_FLAG_TOP = 0x08;
+	public const DOOR_BOTTOM_FLAG_OPEN = 0x04;
+	public const DOOR_TOP_FLAG_RIGHT = 0x01;
+	public const DOOR_TOP_FLAG_POWERED = 0x02;
+
+	public const DOUBLE_PLANT_SUNFLOWER = 0;
+	public const DOUBLE_PLANT_LILAC = 1;
+	public const DOUBLE_PLANT_TALLGRASS = 2;
+	public const DOUBLE_PLANT_LARGE_FERN = 3;
+	public const DOUBLE_PLANT_ROSE_BUSH = 4;
+	public const DOUBLE_PLANT_PEONY = 5;
+
+	public const DOUBLE_PLANT_FLAG_TOP = 0x08;
+
+	public const END_PORTAL_FRAME_FLAG_EYE = 0x04;
+
+	public const FENCE_GATE_FLAG_OPEN = 0x04;
+	public const FENCE_GATE_FLAG_IN_WALL = 0x08;
+
+	public const FLOWER_POPPY = 0;
+	public const FLOWER_BLUE_ORCHID = 1;
+	public const FLOWER_ALLIUM = 2;
+	public const FLOWER_AZURE_BLUET = 3;
+	public const FLOWER_RED_TULIP = 4;
+	public const FLOWER_ORANGE_TULIP = 5;
+	public const FLOWER_WHITE_TULIP = 6;
+	public const FLOWER_PINK_TULIP = 7;
+	public const FLOWER_OXEYE_DAISY = 8;
+	public const FLOWER_CORNFLOWER = 9;
+	public const FLOWER_LILY_OF_THE_VALLEY = 10;
+
+	public const FLOWER_POT_FLAG_OCCUPIED = 0x01;
+
+	public const HOPPER_FLAG_POWERED = 0x08;
+
+	public const INFESTED_STONE = 0;
+	public const INFESTED_COBBLESTONE = 1;
+	public const INFESTED_STONE_BRICK = 2;
+	public const INFESTED_STONE_BRICK_MOSSY = 3;
+	public const INFESTED_STONE_BRICK_CRACKED = 4;
+	public const INFESTED_STONE_BRICK_CHISELED = 5;
+
+	public const ITEM_FRAME_FLAG_HAS_MAP = 0x04;
+
+	public const LANTERN_FLAG_HANGING = 0x01;
+
+	public const LEAVES_FLAG_NO_DECAY = 0x04;
+	public const LEAVES_FLAG_CHECK_DECAY = 0x08;
+
+	public const LEVER_FLAG_POWERED = 0x08;
+
+	public const LIQUID_FLAG_FALLING = 0x08;
+
+	public const NETHER_PORTAL_AXIS_X = 1;
+	public const NETHER_PORTAL_AXIS_Z = 2;
+
+	public const NETHER_REACTOR_INACTIVE = 0;
+	public const NETHER_REACTOR_ACTIVE = 1;
+	public const NETHER_REACTOR_USED = 2;
+
+	public const PRESSURE_PLATE_FLAG_POWERED = 0x01;
+
+	public const PRISMARINE_NORMAL = 0;
+	public const PRISMARINE_DARK = 1;
+	public const PRISMARINE_BRICKS = 2;
+
+	public const PURPUR_NORMAL = 0;
+	public const PURPUR_PILLAR = 2;
+
+	public const QUARTZ_NORMAL = 0;
+	public const QUARTZ_CHISELED = 1;
+	public const QUARTZ_PILLAR = 2;
+	public const QUARTZ_SMOOTH = 3;
+
+	public const RAIL_STRAIGHT_NORTH_SOUTH = 0;
+	public const RAIL_STRAIGHT_EAST_WEST = 1;
+	public const RAIL_ASCENDING_EAST = 2;
+	public const RAIL_ASCENDING_WEST = 3;
+	public const RAIL_ASCENDING_NORTH = 4;
+	public const RAIL_ASCENDING_SOUTH = 5;
+	public const RAIL_CURVE_SOUTHEAST = 6;
+	public const RAIL_CURVE_SOUTHWEST = 7;
+	public const RAIL_CURVE_NORTHWEST = 8;
+	public const RAIL_CURVE_NORTHEAST = 9;
+
+	public const REDSTONE_COMPARATOR_FLAG_SUBTRACT = 0x04;
+	public const REDSTONE_COMPARATOR_FLAG_POWERED = 0x08;
+
+	public const REDSTONE_RAIL_FLAG_POWERED = 0x08;
+
+	public const SANDSTONE_NORMAL = 0;
+	public const SANDSTONE_CHISELED = 1;
+	public const SANDSTONE_CUT = 2;
+	public const SANDSTONE_SMOOTH = 3;
+
+	public const SAPLING_FLAG_READY = 0x08;
+
+	public const SEA_PICKLE_FLAG_NOT_UNDERWATER = 0x04;
+
+	public const SLAB_FLAG_UPPER = 0x08;
+
+	public const SPONGE_FLAG_WET = 0x01;
+
+	public const STAIR_FLAG_UPSIDE_DOWN = 0x04;
+
+	public const STONE_NORMAL = 0;
+	public const STONE_GRANITE = 1;
+	public const STONE_POLISHED_GRANITE = 2;
+	public const STONE_DIORITE = 3;
+	public const STONE_POLISHED_DIORITE = 4;
+	public const STONE_ANDESITE = 5;
+	public const STONE_POLISHED_ANDESITE = 6;
+
+	public const STONE_BRICK_NORMAL = 0;
+	public const STONE_BRICK_MOSSY = 1;
+	public const STONE_BRICK_CRACKED = 2;
+	public const STONE_BRICK_CHISELED = 3;
+
+	public const STONE_SLAB_SMOOTH_STONE = 0;
+	public const STONE_SLAB_SANDSTONE = 1;
+	public const STONE_SLAB_FAKE_WOODEN = 2;
+	public const STONE_SLAB_COBBLESTONE = 3;
+	public const STONE_SLAB_BRICK = 4;
+	public const STONE_SLAB_STONE_BRICK = 5;
+	public const STONE_SLAB_QUARTZ = 6;
+	public const STONE_SLAB_NETHER_BRICK = 7;
+	public const STONE_SLAB2_RED_SANDSTONE = 0;
+	public const STONE_SLAB2_PURPUR = 1;
+	public const STONE_SLAB2_PRISMARINE = 2;
+	public const STONE_SLAB2_DARK_PRISMARINE = 3;
+	public const STONE_SLAB2_PRISMARINE_BRICKS = 4;
+	public const STONE_SLAB2_MOSSY_COBBLESTONE = 5;
+	public const STONE_SLAB2_SMOOTH_SANDSTONE = 6;
+	public const STONE_SLAB2_RED_NETHER_BRICK = 7;
+	public const STONE_SLAB3_END_STONE_BRICK = 0;
+	public const STONE_SLAB3_SMOOTH_RED_SANDSTONE = 1;
+	public const STONE_SLAB3_POLISHED_ANDESITE = 2;
+	public const STONE_SLAB3_ANDESITE = 3;
+	public const STONE_SLAB3_DIORITE = 4;
+	public const STONE_SLAB3_POLISHED_DIORITE = 5;
+	public const STONE_SLAB3_GRANITE = 6;
+	public const STONE_SLAB3_POLISHED_GRANITE = 7;
+	public const STONE_SLAB4_MOSSY_STONE_BRICK = 0;
+	public const STONE_SLAB4_SMOOTH_QUARTZ = 1;
+	public const STONE_SLAB4_STONE = 2;
+	public const STONE_SLAB4_CUT_SANDSTONE = 3;
+	public const STONE_SLAB4_CUT_RED_SANDSTONE = 4;
+
+	public const TALLGRASS_NORMAL = 1;
+	public const TALLGRASS_FERN = 2;
+
+	public const TNT_NORMAL = 0;
+	public const TNT_UNDERWATER = 2;
+
+	public const TNT_FLAG_UNSTABLE = 0x01;
+
+	public const TRAPDOOR_FLAG_UPPER = 0x04;
+	public const TRAPDOOR_FLAG_OPEN = 0x08;
+
+	public const TRIPWIRE_FLAG_TRIGGERED = 0x01;
+	public const TRIPWIRE_FLAG_SUSPENDED = 0x02;
+	public const TRIPWIRE_FLAG_CONNECTED = 0x04;
+	public const TRIPWIRE_FLAG_DISARMED = 0x08;
+
+	public const TRIPWIRE_HOOK_FLAG_CONNECTED = 0x04;
+	public const TRIPWIRE_HOOK_FLAG_POWERED = 0x08;
+
+	public const VINE_FLAG_SOUTH = 0x01;
+	public const VINE_FLAG_WEST = 0x02;
+	public const VINE_FLAG_NORTH = 0x04;
+	public const VINE_FLAG_EAST = 0x08;
+
+	public const WALL_COBBLESTONE = 0;
+	public const WALL_MOSSY_COBBLESTONE = 1;
+	public const WALL_GRANITE = 2;
+	public const WALL_DIORITE = 3;
+	public const WALL_ANDESITE = 4;
+	public const WALL_SANDSTONE = 5;
+	public const WALL_BRICK = 6;
+	public const WALL_STONE_BRICK = 7;
+	public const WALL_MOSSY_STONE_BRICK = 8;
+	public const WALL_NETHER_BRICK = 9;
+	public const WALL_END_STONE_BRICK = 10;
+	public const WALL_PRISMARINE = 11;
+	public const WALL_RED_SANDSTONE = 12;
+	public const WALL_RED_NETHER_BRICK = 13;
+}

src/pocketmine/block/BlockToolType.php

@@ -29,11 +29,11 @@ namespace pocketmine\block;
  */
 interface BlockToolType{
 
-	public const TYPE_NONE = 0;
-	public const TYPE_SWORD = 1 << 0;
-	public const TYPE_SHOVEL = 1 << 1;
-	public const TYPE_PICKAXE = 1 << 2;
-	public const TYPE_AXE = 1 << 3;
-	public const TYPE_SHEARS = 1 << 4;
+	public const NONE = 0;
+	public const SWORD = 1 << 0;
+	public const SHOVEL = 1 << 1;
+	public const PICKAXE = 1 << 2;
+	public const AXE = 1 << 3;
+	public const SHEARS = 1 << 4;
 
 }

src/pocketmine/block/BlueIce.php

@@ -0,0 +1,45 @@
+<?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;
+
+use pocketmine\item\Item;
+
+class BlueIce extends Opaque{
+
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(2.8, BlockToolType::PICKAXE));
+	}
+
+	public function getLightLevel() : int{
+		return 1;
+	}
+
+	public function getFrictionFactor() : float{
+		return 0.99;
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [];
+	}
+}

src/pocketmine/block/BoneBlock.php

@@ -23,42 +23,13 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\PillarRotationHelper;
-use pocketmine\item\Item;
-use pocketmine\item\TieredTool;
-use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\block\utils\PillarRotationTrait;
+use pocketmine\item\ToolTier;
 
-class BoneBlock extends Solid{
+class BoneBlock extends Opaque{
+	use PillarRotationTrait;
 
-	protected $id = Block::BONE_BLOCK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Bone Block";
-	}
-
-	public function getHardness() : float{
-		return 2;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
-	}
-
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$this->meta = PillarRotationHelper::getMetaFromFace($this->meta, $face);
-		return $this->getLevel()->setBlock($blockReplace, $this, true, true);
-	}
-
-	public function getVariantBitmask() : int{
-		return 0x03;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(2.0, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel()));
 	}
 }

src/pocketmine/block/Bookshelf.php

@@ -24,31 +24,17 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
 
-class Bookshelf extends Solid{
+class Bookshelf extends Opaque{
 
-	protected $id = self::BOOKSHELF;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Bookshelf";
-	}
-
-	public function getHardness() : float{
-		return 1.5;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_AXE;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(1.5, BlockToolType::AXE));
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::BOOK, 0, 3)
+			VanillaItems::BOOK()->setCount(3)
 		];
 	}
 

src/pocketmine/block/BrewingStand.php

@@ -23,38 +23,53 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\tile\BrewingStand as TileBrewingStand;
 use pocketmine\item\Item;
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
 
 class BrewingStand extends Transparent{
 
-	protected $id = self::BREWING_STAND_BLOCK;
+	/** @var bool */
+	protected $eastSlot = false;
+	/** @var bool */
+	protected $northwestSlot = false;
+	/** @var bool */
+	protected $southwestSlot = false;
 
-	protected $itemId = Item::BREWING_STAND;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.5, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel()));
 	}
 
-	public function getName() : string{
-		return "Brewing Stand";
+	protected function writeStateToMeta() : int{
+		return ($this->eastSlot ? BlockLegacyMetadata::BREWING_STAND_FLAG_EAST : 0) |
+			($this->southwestSlot ? BlockLegacyMetadata::BREWING_STAND_FLAG_SOUTHWEST : 0) |
+			($this->northwestSlot ? BlockLegacyMetadata::BREWING_STAND_FLAG_NORTHWEST : 0);
 	}
 
-	public function getHardness() : float{
-		return 0.5;
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->eastSlot = ($stateMeta & BlockLegacyMetadata::BREWING_STAND_FLAG_EAST) !== 0;
+		$this->southwestSlot = ($stateMeta & BlockLegacyMetadata::BREWING_STAND_FLAG_SOUTHWEST) !== 0;
+		$this->northwestSlot = ($stateMeta & BlockLegacyMetadata::BREWING_STAND_FLAG_NORTHWEST) !== 0;
 	}
 
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
+	public function getStateBitmask() : int{
+		return 0b111;
 	}
 
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player instanceof Player){
+			$stand = $this->getWorld()->getTile($this);
+			if($stand instanceof TileBrewingStand and $stand->canOpenWith($item->getCustomName())){
+				$player->setCurrentWindow($stand->getInventory());
+			}
+		}
+
+		return true;
 	}
 
-	public function getVariantBitmask() : int{
-		return 0;
+	public function onScheduledUpdate() : void{
+		//TODO
 	}
-
-	//TODO
 }

src/pocketmine/block/BrownMushroom.php

@@ -25,12 +25,6 @@ namespace pocketmine\block;
 
 class BrownMushroom extends RedMushroom{
 
-	protected $id = self::BROWN_MUSHROOM;
-
-	public function getName() : string{
-		return "Brown Mushroom";
-	}
-
 	public function getLightLevel() : int{
 		return 1;
 	}

src/pocketmine/block/BrownMushroomBlock.php

@@ -28,15 +28,9 @@ use function mt_rand;
 
 class BrownMushroomBlock extends RedMushroomBlock{
 
-	protected $id = Block::BROWN_MUSHROOM_BLOCK;
-
-	public function getName() : string{
-		return "Brown Mushroom Block";
-	}
-
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			Item::get(Item::BROWN_MUSHROOM, 0, mt_rand(0, 2))
+			VanillaBlocks::BROWN_MUSHROOM()->asItem()->setCount(mt_rand(0, 2))
 		];
 	}
 }

src/pocketmine/block/BurningFurnace.php

@@ -1,98 +0,0 @@
-<?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;
-
-use pocketmine\item\Item;
-use pocketmine\item\TieredTool;
-use pocketmine\math\Vector3;
-use pocketmine\Player;
-use pocketmine\tile\Furnace as TileFurnace;
-use pocketmine\tile\Tile;
-
-class BurningFurnace extends Solid{
-
-	protected $id = self::BURNING_FURNACE;
-
-	protected $itemId = self::FURNACE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Burning Furnace";
-	}
-
-	public function getHardness() : float{
-		return 3.5;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
-	}
-
-	public function getLightLevel() : int{
-		return 13;
-	}
-
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$faces = [
-			0 => 4,
-			1 => 2,
-			2 => 5,
-			3 => 3
-		];
-		$this->meta = $faces[$player instanceof Player ? $player->getDirection() : 0];
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
-
-		Tile::createTile(Tile::FURNACE, $this->getLevel(), TileFurnace::createNBT($this, $face, $item, $player));
-
-		return true;
-	}
-
-	public function onActivate(Item $item, Player $player = null) : bool{
-		if($player instanceof Player){
-			$furnace = $this->getLevel()->getTile($this);
-			if(!($furnace instanceof TileFurnace)){
-				$furnace = Tile::createTile(Tile::FURNACE, $this->getLevel(), TileFurnace::createNBT($this));
-			}
-
-			if(!$furnace->canOpenWith($item->getCustomName())){
-				return true;
-			}
-
-			$player->addWindow($furnace->getInventory());
-		}
-
-		return true;
-	}
-
-	public function getVariantBitmask() : int{
-		return 0;
-	}
-}

src/pocketmine/block/Button.php

@@ -23,29 +23,60 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\item\Item;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\sound\RedstonePowerOffSound;
+use pocketmine\world\sound\RedstonePowerOnSound;
 
 abstract class Button extends Flowable{
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	/** @var int */
+	protected $facing = Facing::DOWN;
+	/** @var bool */
+	protected $powered = false;
+
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeFacing($this->facing) | ($this->powered ? BlockLegacyMetadata::BUTTON_FLAG_POWERED : 0);
 	}
 
-	public function getVariantBitmask() : int{
-		return 0;
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		//TODO: in PC it's (6 - facing) for every meta except 0 (down)
+		$this->facing = BlockDataSerializer::readFacing($stateMeta & 0x07);
+		$this->powered = ($stateMeta & BlockLegacyMetadata::BUTTON_FLAG_POWERED) !== 0;
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		//TODO: check valid target block
-		$this->meta = $face;
-
-		return $this->level->setBlock($this, $this, true, true);
+		$this->facing = $face;
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	public function onActivate(Item $item, Player $player = null) : bool{
-		//TODO
+	abstract protected function getActivationTime() : int;
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$this->powered){
+			$this->powered = true;
+			$this->world->setBlock($this, $this);
+			$this->world->scheduleDelayedBlockUpdate($this, $this->getActivationTime());
+			$this->world->addSound($this->add(0.5, 0.5, 0.5), new RedstonePowerOnSound());
+		}
+
 		return true;
 	}
+
+	public function onScheduledUpdate() : void{
+		if($this->powered){
+			$this->powered = false;
+			$this->world->setBlock($this, $this);
+			$this->world->addSound($this->add(0.5, 0.5, 0.5), new RedstonePowerOffSound());
+		}
+	}
 }

src/pocketmine/block/Cactus.php

@@ -23,61 +23,62 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\entity\Entity;
 use pocketmine\event\block\BlockGrowEvent;
 use pocketmine\event\entity\EntityDamageByBlockEvent;
 use pocketmine\event\entity\EntityDamageEvent;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
 class Cactus extends Transparent{
 
-	protected $id = self::CACTUS;
+	/** @var int */
+	protected $age = 0;
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.4));
 	}
 
-	public function getHardness() : float{
-		return 0.4;
+	protected function writeStateToMeta() : int{
+		return $this->age;
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->age = BlockDataSerializer::readBoundedInt("age", $stateMeta, 0, 15);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
 	}
 
 	public function hasEntityCollision() : bool{
 		return true;
 	}
 
-	public function getName() : string{
-		return "Cactus";
-	}
-
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-
-		return new AxisAlignedBB(
-			$this->x + 0.0625,
-			$this->y + 0.0625,
-			$this->z + 0.0625,
-			$this->x + 0.9375,
-			$this->y + 0.9375,
-			$this->z + 0.9375
-		);
+		static $shrinkSize = 1 / 16;
+		return AxisAlignedBB::one()->contract($shrinkSize, 0, $shrinkSize)->trim(Facing::UP, $shrinkSize);
 	}
 
-	public function onEntityCollide(Entity $entity) : void{
+	public function onEntityInside(Entity $entity) : void{
 		$ev = new EntityDamageByBlockEvent($this, $entity, EntityDamageEvent::CAUSE_CONTACT, 1);
 		$entity->attack($ev);
 	}
 
 	public function onNearbyBlockChange() : void{
-		$down = $this->getSide(Vector3::SIDE_DOWN);
-		if($down->getId() !== self::SAND and $down->getId() !== self::CACTUS){
-			$this->getLevel()->useBreakOn($this);
+		$down = $this->getSide(Facing::DOWN);
+		if($down->getId() !== BlockLegacyIds::SAND and !$down->isSameType($this)){
+			$this->getWorld()->useBreakOn($this);
 		}else{
-			for($side = 2; $side <= 5; ++$side){
+			foreach(Facing::HORIZONTAL as $side){
 				$b = $this->getSide($side);
 				if($b->isSolid()){
-					$this->getLevel()->useBreakOn($this);
+					$this->getWorld()->useBreakOn($this);
 					break;
 				}
 			}
@@ -89,48 +90,42 @@ class Cactus extends Transparent{
 	}
 
 	public function onRandomTick() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->getId() !== self::CACTUS){
-			if($this->meta === 0x0f){
+		if(!$this->getSide(Facing::DOWN)->isSameType($this)){
+			if($this->age === 15){
 				for($y = 1; $y < 3; ++$y){
-					$b = $this->getLevel()->getBlockAt($this->x, $this->y + $y, $this->z);
-					if($b->getId() === self::AIR){
-						$ev = new BlockGrowEvent($b, BlockFactory::get(Block::CACTUS));
+					$b = $this->getWorld()->getBlockAt($this->x, $this->y + $y, $this->z);
+					if($b->getId() === BlockLegacyIds::AIR){
+						$ev = new BlockGrowEvent($b, VanillaBlocks::CACTUS());
 						$ev->call();
 						if($ev->isCancelled()){
 							break;
 						}
-						$this->getLevel()->setBlock($b, $ev->getNewState(), true);
+						$this->getWorld()->setBlock($b, $ev->getNewState());
 					}else{
 						break;
 					}
 				}
-				$this->meta = 0;
-				$this->getLevel()->setBlock($this, $this);
+				$this->age = 0;
+				$this->getWorld()->setBlock($this, $this);
 			}else{
-				++$this->meta;
-				$this->getLevel()->setBlock($this, $this);
+				++$this->age;
+				$this->getWorld()->setBlock($this, $this);
 			}
 		}
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$down = $this->getSide(Vector3::SIDE_DOWN);
-		if($down->getId() === self::SAND or $down->getId() === self::CACTUS){
-			$block0 = $this->getSide(Vector3::SIDE_NORTH);
-			$block1 = $this->getSide(Vector3::SIDE_SOUTH);
-			$block2 = $this->getSide(Vector3::SIDE_WEST);
-			$block3 = $this->getSide(Vector3::SIDE_EAST);
-			if(!$block0->isSolid() and !$block1->isSolid() and !$block2->isSolid() and !$block3->isSolid()){
-				$this->getLevel()->setBlock($this, $this, true);
-
-				return true;
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$down = $this->getSide(Facing::DOWN);
+		if($down->getId() === BlockLegacyIds::SAND or $down->isSameType($this)){
+			foreach(Facing::HORIZONTAL as $side){
+				if($this->getSide($side)->isSolid()){
+					return false;
+				}
 			}
+
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
 		return false;
 	}
-
-	public function getVariantBitmask() : int{
-		return 0;
-	}
 }

src/pocketmine/block/Cake.php

@@ -23,60 +23,57 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\entity\EffectInstance;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\entity\effect\EffectInstance;
 use pocketmine\entity\Living;
 use pocketmine\item\FoodSource;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
 class Cake extends Transparent implements FoodSource{
 
-	protected $id = self::CAKE_BLOCK;
+	/** @var int */
+	protected $bites = 0;
 
-	protected $itemId = Item::CAKE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.5));
 	}
 
-	public function getHardness() : float{
-		return 0.5;
+	protected function writeStateToMeta() : int{
+		return $this->bites;
 	}
 
-	public function getName() : string{
-		return "Cake";
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->bites = BlockDataSerializer::readBoundedInt("bites", $stateMeta, 0, 6);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b111;
 	}
 
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-
-		$f = $this->getDamage() * 0.125; //1 slice width
-
-		return new AxisAlignedBB(
-			$this->x + 0.0625 + $f,
-			$this->y,
-			$this->z + 0.0625,
-			$this->x + 1 - 0.0625,
-			$this->y + 0.5,
-			$this->z + 1 - 0.0625
-		);
+		return AxisAlignedBB::one()
+			->contract(1 / 16, 0, 1 / 16)
+			->trim(Facing::UP, 0.5)
+			->trim(Facing::WEST, $this->bites / 8);
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$down = $this->getSide(Vector3::SIDE_DOWN);
-		if($down->getId() !== self::AIR){
-			$this->getLevel()->setBlock($blockReplace, $this, true, true);
-
-			return true;
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$down = $this->getSide(Facing::DOWN);
+		if($down->getId() !== BlockLegacyIds::AIR){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
 		return false;
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->getId() === self::AIR){ //Replace with common break method
-			$this->getLevel()->setBlock($this, BlockFactory::get(Block::AIR), true);
+		if($this->getSide(Facing::DOWN)->getId() === BlockLegacyIds::AIR){ //Replace with common break method
+			$this->getWorld()->setBlock($this, VanillaBlocks::AIR());
 		}
 	}
 
@@ -88,7 +85,7 @@ class Cake extends Transparent implements FoodSource{
 		return false;
 	}
 
-	public function onActivate(Item $item, Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player !== null){
 			$player->consumeObject($this);
 			return true;
@@ -114,9 +111,9 @@ class Cake extends Transparent implements FoodSource{
 	 */
 	public function getResidue(){
 		$clone = clone $this;
-		$clone->meta++;
-		if($clone->meta > 0x06){
-			$clone = BlockFactory::get(Block::AIR);
+		$clone->bites++;
+		if($clone->bites > 6){
+			$clone = VanillaBlocks::AIR();
 		}
 		return $clone;
 	}
@@ -129,6 +126,6 @@ class Cake extends Transparent implements FoodSource{
 	}
 
 	public function onConsume(Living $consumer) : void{
-		$this->level->setBlock($this, $this->getResidue());
+		$this->world->setBlock($this, $this->getResidue());
 	}
 }

src/pocketmine/block/Carpet.php

@@ -23,58 +23,39 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\ColorBlockMetaHelper;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
 class Carpet extends Flowable{
 
-	protected $id = self::CARPET;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getHardness() : float{
-		return 0.1;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.1));
 	}
 
 	public function isSolid() : bool{
 		return true;
 	}
 
-	public function getName() : string{
-		return ColorBlockMetaHelper::getColorFromMeta($this->getVariant()) . " Carpet";
-	}
-
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-
-		return new AxisAlignedBB(
-			$this->x,
-			$this->y,
-			$this->z,
-			$this->x + 1,
-			$this->y + 0.0625,
-			$this->z + 1
-		);
+		return AxisAlignedBB::one()->trim(Facing::UP, 15 / 16);
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$down = $this->getSide(Vector3::SIDE_DOWN);
-		if($down->getId() !== self::AIR){
-			$this->getLevel()->setBlock($blockReplace, $this, true, true);
-
-			return true;
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$down = $this->getSide(Facing::DOWN);
+		if($down->getId() !== BlockLegacyIds::AIR){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
 		return false;
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->getId() === self::AIR){
-			$this->getLevel()->useBreakOn($this);
+		if($this->getSide(Facing::DOWN)->getId() === BlockLegacyIds::AIR){
+			$this->getWorld()->useBreakOn($this);
 		}
 	}
 

src/pocketmine/block/Carrot.php

@@ -24,28 +24,18 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
 use function mt_rand;
 
 class Carrot extends Crops{
 
-	protected $id = self::CARROT_BLOCK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Carrot Block";
-	}
-
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::CARROT, 0, $this->meta >= 0x07 ? mt_rand(1, 4) : 1)
+			VanillaItems::CARROT()->setCount($this->age >= 7 ? mt_rand(1, 4) : 1)
 		];
 	}
 
-	public function getPickedItem() : Item{
-		return ItemFactory::get(Item::CARROT);
+	public function getPickedItem(bool $addUserData = false) : Item{
+		return VanillaItems::CARROT();
 	}
 }

src/pocketmine/block/CarvedPumpkin.php

@@ -0,0 +1,56 @@
+<?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;
+
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+
+class CarvedPumpkin extends Opaque{
+
+	/** @var int */
+	protected $facing = Facing::NORTH;
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03);
+	}
+
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeLegacyHorizontalFacing($this->facing);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b11;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player !== null){
+			$this->facing = Facing::opposite($player->getHorizontalFacing());
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+}

src/pocketmine/block/Chest.php

@@ -23,112 +23,89 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\tile\Chest as TileChest;
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
-use pocketmine\tile\Chest as TileChest;
-use pocketmine\tile\Tile;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
 class Chest extends Transparent{
 
-	protected $id = self::CHEST;
+	/** @var int */
+	protected $facing = Facing::NORTH;
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(2.5, BlockToolType::AXE));
 	}
 
-	public function getHardness() : float{
-		return 2.5;
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeHorizontalFacing($this->facing);
 	}
 
-	public function getName() : string{
-		return "Chest";
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readHorizontalFacing($stateMeta);
 	}
 
-	public function getToolType() : int{
-		return BlockToolType::TYPE_AXE;
+	public function getStateBitmask() : int{
+		return 0b111;
 	}
 
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
 		//these are slightly bigger than in PC
-		return new AxisAlignedBB(
-			$this->x + 0.025,
-			$this->y,
-			$this->z + 0.025,
-			$this->x + 0.975,
-			$this->y + 0.95,
-			$this->z + 0.975
-		);
+		return AxisAlignedBB::one()->contract(0.025, 0, 0.025)->trim(Facing::UP, 0.05);
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$faces = [
-			0 => 4,
-			1 => 2,
-			2 => 5,
-			3 => 3
-		];
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player !== null){
+			$this->facing = Facing::opposite($player->getHorizontalFacing());
+		}
 
-		$chest = null;
-		$this->meta = $faces[$player instanceof Player ? $player->getDirection() : 0];
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
 
-		for($side = 2; $side <= 5; ++$side){
-			if(($this->meta === 4 or $this->meta === 5) and ($side === 4 or $side === 5)){
-				continue;
-			}elseif(($this->meta === 3 or $this->meta === 2) and ($side === 2 or $side === 3)){
-				continue;
-			}
-			$c = $this->getSide($side);
-			if($c->getId() === $this->id and $c->getDamage() === $this->meta){
-				$tile = $this->getLevel()->getTile($c);
-				if($tile instanceof TileChest and !$tile->isPaired()){
-					$chest = $tile;
-					break;
+	public function onPostPlace() : void{
+		$tile = $this->world->getTile($this);
+		if($tile instanceof TileChest){
+			foreach([
+				Facing::rotateY($this->facing, true),
+				Facing::rotateY($this->facing, false)
+			] as $side){
+				$c = $this->getSide($side);
+				if($c instanceof Chest and $c->isSameType($this) and $c->facing === $this->facing){
+					$pair = $this->world->getTile($c);
+					if($pair instanceof TileChest and !$pair->isPaired()){
+						$pair->pairWith($tile);
+						$tile->pairWith($pair);
+						break;
+					}
 				}
 			}
 		}
-
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
-		$tile = Tile::createTile(Tile::CHEST, $this->getLevel(), TileChest::createNBT($this, $face, $item, $player));
-
-		if($chest instanceof TileChest and $tile instanceof TileChest){
-			$chest->pairWith($tile);
-			$tile->pairWith($chest);
-		}
-
-		return true;
 	}
 
-	public function onActivate(Item $item, Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player instanceof Player){
 
-			$t = $this->getLevel()->getTile($this);
-			$chest = null;
-			if($t instanceof TileChest){
-				$chest = $t;
-			}else{
-				$chest = Tile::createTile(Tile::CHEST, $this->getLevel(), TileChest::createNBT($this));
-			}
+			$chest = $this->getWorld()->getTile($this);
+			if($chest instanceof TileChest){
+				if(
+					!$this->getSide(Facing::UP)->isTransparent() or
+					($chest->isPaired() and !$chest->getPair()->getBlock()->getSide(Facing::UP)->isTransparent()) or
+					!$chest->canOpenWith($item->getCustomName())
+				){
+					return true;
+				}
 
-			if(
-				!$this->getSide(Vector3::SIDE_UP)->isTransparent() or
-				($chest->isPaired() and !$chest->getPair()->getBlock()->getSide(Vector3::SIDE_UP)->isTransparent()) or
-				!$chest->canOpenWith($item->getCustomName())
-			){
-				return true;
+				$player->setCurrentWindow($chest->getInventory());
 			}
-
-			$player->addWindow($chest->getInventory());
 		}
 
 		return true;
 	}
 
-	public function getVariantBitmask() : int{
-		return 0;
-	}
-
 	public function getFuelTime() : int{
 		return 300;
 	}

src/pocketmine/block/Clay.php

@@ -24,31 +24,17 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
 
-class Clay extends Solid{
+class Clay extends Opaque{
 
-	protected $id = self::CLAY_BLOCK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getHardness() : float{
-		return 0.6;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_SHOVEL;
-	}
-
-	public function getName() : string{
-		return "Clay Block";
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.6, BlockToolType::SHOVEL));
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::CLAY_BALL, 0, 4)
+			VanillaItems::CLAY()->setCount(4)
 		];
 	}
 }

src/pocketmine/block/Coal.php

@@ -23,30 +23,12 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
 
-class Coal extends Solid{
+class Coal extends Opaque{
 
-	protected $id = self::COAL_BLOCK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getHardness() : float{
-		return 5;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
-	}
-
-	public function getName() : string{
-		return "Coal Block";
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(5.0, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel(), 30.0));
 	}
 
 	public function getFuelTime() : int{

src/pocketmine/block/CoalOre.php

@@ -24,37 +24,19 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
+use pocketmine\item\VanillaItems;
 use function mt_rand;
 
-class CoalOre extends Solid{
+class CoalOre extends Opaque{
 
-	protected $id = self::COAL_ORE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getHardness() : float{
-		return 3;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
-	}
-
-	public function getName() : string{
-		return "Coal Ore";
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(3.0, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel()));
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::COAL)
+			VanillaItems::COAL()
 		];
 	}
 

src/pocketmine/block/CoarseDirt.php

@@ -23,29 +23,21 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\item\Hoe;
 use pocketmine\item\Item;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
 
-class InvisibleBedrock extends Transparent{
+class CoarseDirt extends Dirt{
 
-	protected $id = self::INVISIBLE_BEDROCK;
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($face === Facing::UP and $item instanceof Hoe){
+			$item->applyDamage(1);
+			$this->getWorld()->setBlock($this, VanillaBlocks::DIRT());
+			return true;
+		}
 
-	public function __construct(){
-
-	}
-
-	public function getName() : string{
-		return "Invisible Bedrock";
-	}
-
-	public function getHardness() : float{
-		return -1;
-	}
-
-	public function getBlastResistance() : float{
-		return 18000000;
-	}
-
-	public function isBreakable(Item $item) : bool{
 		return false;
 	}
 }

src/pocketmine/block/CobblestoneWall.php

@@ -1,117 +0,0 @@
-<?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;
-
-use pocketmine\item\TieredTool;
-use pocketmine\math\AxisAlignedBB;
-use pocketmine\math\Vector3;
-
-class CobblestoneWall extends Transparent{
-	public const NONE_MOSSY_WALL = 0;
-	public const MOSSY_WALL = 1;
-	public const GRANITE_WALL = 2;
-	public const DIORITE_WALL = 3;
-	public const ANDESITE_WALL = 4;
-	public const SANDSTONE_WALL = 5;
-	public const BRICK_WALL = 6;
-	public const STONE_BRICK_WALL = 7;
-	public const MOSSY_STONE_BRICK_WALL = 8;
-	public const NETHER_BRICK_WALL = 9;
-	public const END_STONE_BRICK_WALL = 10;
-	public const PRISMARINE_WALL = 11;
-	public const RED_SANDSTONE_WALL = 12;
-	public const RED_NETHER_BRICK_WALL = 13;
-
-	protected $id = self::COBBLESTONE_WALL;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
-	}
-
-	public function getHardness() : float{
-		return 2;
-	}
-
-	public function getName() : string{
-		static $names = [
-			self::NONE_MOSSY_WALL => "Cobblestone",
-			self::MOSSY_WALL => "Mossy Cobblestone",
-			self::GRANITE_WALL => "Granite",
-			self::DIORITE_WALL => "Diorite",
-			self::ANDESITE_WALL => "Andesite",
-			self::SANDSTONE_WALL => "Sandstone",
-			self::BRICK_WALL => "Brick",
-			self::STONE_BRICK_WALL => "Stone Brick",
-			self::MOSSY_STONE_BRICK_WALL => "Mossy Stone Brick",
-			self::NETHER_BRICK_WALL => "Nether Brick",
-			self::END_STONE_BRICK_WALL => "End Stone Brick",
-			self::PRISMARINE_WALL => "Prismarine",
-			self::RED_SANDSTONE_WALL => "Red Sandstone",
-			self::RED_NETHER_BRICK_WALL => "Red Nether Brick"
-		];
-		return ($names[$this->getVariant()] ?? "Unknown") . " Wall";
-	}
-
-	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-		//walls don't have any special collision boxes like fences do
-
-		$north = $this->canConnect($this->getSide(Vector3::SIDE_NORTH));
-		$south = $this->canConnect($this->getSide(Vector3::SIDE_SOUTH));
-		$west = $this->canConnect($this->getSide(Vector3::SIDE_WEST));
-		$east = $this->canConnect($this->getSide(Vector3::SIDE_EAST));
-
-		$inset = 0.25;
-		if(
-			$this->getSide(Vector3::SIDE_UP)->getId() === Block::AIR and //if there is a block on top, it stays as a post
-			(
-				($north and $south and !$west and !$east) or
-				(!$north and !$south and $west and $east)
-			)
-		){
-			//If connected to two sides on the same axis but not any others, AND there is not a block on top, there is no post and the wall is thinner
-			$inset = 0.3125;
-		}
-
-		return new AxisAlignedBB(
-			$this->x + ($west ? 0 : $inset),
-			$this->y,
-			$this->z + ($north ? 0 : $inset),
-			$this->x + 1 - ($east ? 0 : $inset),
-			$this->y + 1.5,
-			$this->z + 1 - ($south ? 0 : $inset)
-		);
-	}
-
-	public function canConnect(Block $block){
-		return $block instanceof static or $block instanceof FenceGate or ($block->isSolid() and !$block->isTransparent());
-	}
-}

src/pocketmine/block/Cobweb.php

@@ -25,43 +25,25 @@ namespace pocketmine\block;
 
 use pocketmine\entity\Entity;
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
 
 class Cobweb extends Flowable{
 
-	protected $id = self::COBWEB;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(4.0, BlockToolType::SWORD | BlockToolType::SHEARS, 1));
 	}
 
 	public function hasEntityCollision() : bool{
 		return true;
 	}
 
-	public function getName() : string{
-		return "Cobweb";
-	}
-
-	public function getHardness() : float{
-		return 4;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_SWORD | BlockToolType::TYPE_SHEARS;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return 1;
-	}
-
-	public function onEntityCollide(Entity $entity) : void{
+	public function onEntityInside(Entity $entity) : void{
 		$entity->resetFallDistance();
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::STRING)
+			VanillaItems::STRING()
 		];
 	}
 

src/pocketmine/block/CocoaBlock.php

@@ -23,29 +23,102 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\block\utils\TreeType;
+use pocketmine\item\Fertilizer;
+use pocketmine\item\Item;
+use pocketmine\item\VanillaItems;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use function mt_rand;
+
 class CocoaBlock extends Transparent{
 
-	protected $id = self::COCOA_BLOCK;
+	/** @var int */
+	protected $facing = Facing::NORTH;
+	/** @var int */
+	protected $age = 0;
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.2, BlockToolType::AXE, 0, 15.0));
 	}
 
-	public function getName() : string{
-		return "Cocoa Block";
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeLegacyHorizontalFacing(Facing::opposite($this->facing)) | ($this->age << 2);
 	}
 
-	public function getHardness() : float{
-		return 0.2;
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = Facing::opposite(BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03));
+		$this->age = BlockDataSerializer::readBoundedInt("age", $stateMeta >> 2, 0, 2);
 	}
 
-	public function getToolType() : int{
-		return BlockToolType::TYPE_AXE;
+	public function getStateBitmask() : int{
+		return 0b1111;
 	}
 
-	//TODO
-
 	public function isAffectedBySilkTouch() : bool{
 		return false;
 	}
+
+	protected function recalculateBoundingBox() : ?AxisAlignedBB{
+		return AxisAlignedBB::one()
+			->squash(Facing::axis(Facing::rotateY($this->facing, true)), (6 - $this->age) / 16) //sides
+			->trim(Facing::DOWN, (7 - $this->age * 2) / 16)
+			->trim(Facing::UP, 0.25)
+			->trim(Facing::opposite($this->facing), 1 / 16) //gap between log and pod
+			->trim($this->facing, (11 - $this->age * 2) / 16); //outward face
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(Facing::axis($face) !== Facing::AXIS_Y and $blockClicked instanceof Wood and $blockClicked->getTreeType()->equals(TreeType::JUNGLE())){
+			$this->facing = $face;
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+		}
+
+		return false;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($this->age < 2 and $item instanceof Fertilizer){
+			$this->age++;
+			$this->world->setBlock($this, $this);
+
+			$item->pop();
+
+			return true;
+		}
+
+		return false;
+	}
+
+	public function onNearbyBlockChange() : void{
+		$side = $this->getSide(Facing::opposite($this->facing));
+		if(!($side instanceof Wood) or !$side->getTreeType()->equals(TreeType::JUNGLE())){
+			$this->world->useBreakOn($this);
+		}
+	}
+
+	public function ticksRandomly() : bool{
+		return true;
+	}
+
+	public function onRandomTick() : void{
+		if($this->age < 2 and mt_rand(1, 5) === 1){
+			$this->age++;
+			$this->world->setBlock($this, $this);
+		}
+	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [
+			VanillaItems::COCOA_BEANS()->setCount($this->age === 2 ? mt_rand(2, 3) : 1)
+		];
+	}
+
+	public function getPickedItem(bool $addUserData = false) : Item{
+		return VanillaItems::COCOA_BEANS();
+	}
 }

src/pocketmine/block/Concrete.php

@@ -23,30 +23,11 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\ColorBlockMetaHelper;
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
 
-class Concrete extends Solid{
+class Concrete extends Opaque{
 
-	protected $id = Block::CONCRETE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return ColorBlockMetaHelper::getColorFromMeta($this->getVariant()) . " Concrete";
-	}
-
-	public function getHardness() : float{
-		return 1.8;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(1.8, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel()));
 	}
 }

src/pocketmine/block/ConcretePowder.php

@@ -23,33 +23,24 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\block\utils\ColorBlockMetaHelper;
+use pocketmine\block\utils\Fallable;
+use pocketmine\block\utils\FallableTrait;
+use pocketmine\math\Facing;
 
-class ConcretePowder extends Fallable{
-
-	protected $id = self::CONCRETE_POWDER;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+class ConcretePowder extends Opaque implements Fallable{
+	use FallableTrait {
+		onNearbyBlockChange as protected startFalling;
 	}
 
-	public function getName() : string{
-		return ColorBlockMetaHelper::getColorFromMeta($this->getVariant()) . " Concrete Powder";
-	}
-
-	public function getHardness() : float{
-		return 0.5;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_SHOVEL;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.5, BlockToolType::SHOVEL));
 	}
 
 	public function onNearbyBlockChange() : void{
 		if(($block = $this->checkAdjacentWater()) !== null){
-			$this->level->setBlock($this, $block);
+			$this->world->setBlock($this, $block);
 		}else{
-			parent::onNearbyBlockChange();
+			$this->startFalling();
 		}
 	}
 
@@ -64,9 +55,12 @@ class ConcretePowder extends Fallable{
 	 * @return null|Block
 	 */
 	private function checkAdjacentWater() : ?Block{
-		for($i = 1; $i < 6; ++$i){ //Do not check underneath
+		foreach(Facing::ALL as $i){
+			if($i === Facing::DOWN){
+				continue;
+			}
 			if($this->getSide($i) instanceof Water){
-				return BlockFactory::get(Block::CONCRETE, $this->meta);
+				return BlockFactory::get(BlockLegacyIds::CONCRETE, $this->idInfo->getVariant());
 			}
 		}
 

src/pocketmine/block/CraftingTable.php

@@ -23,31 +23,18 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\inventory\CraftingGrid;
+use pocketmine\crafting\CraftingGrid;
 use pocketmine\item\Item;
-use pocketmine\Player;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
 
-class CraftingTable extends Solid{
+class CraftingTable extends Opaque{
 
-	protected $id = self::CRAFTING_TABLE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(2.5, BlockToolType::AXE));
 	}
 
-	public function getHardness() : float{
-		return 2.5;
-	}
-
-	public function getName() : string{
-		return "Crafting Table";
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_AXE;
-	}
-
-	public function onActivate(Item $item, Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player instanceof Player){
 			$player->setCraftingGrid(new CraftingGrid($player, CraftingGrid::SIZE_BIG));
 		}

src/pocketmine/block/Crops.php

@@ -23,40 +23,60 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\event\block\BlockGrowEvent;
+use pocketmine\item\Fertilizer;
 use pocketmine\item\Item;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 use function mt_rand;
 
 abstract class Crops extends Flowable{
+	/** @var int */
+	protected $age = 0;
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		if($blockReplace->getSide(Vector3::SIDE_DOWN)->getId() === Block::FARMLAND){
-			$this->getLevel()->setBlock($blockReplace, $this, true, true);
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? BlockBreakInfo::instant());
+	}
 
-			return true;
+	protected function writeStateToMeta() : int{
+		return $this->age;
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->age = BlockDataSerializer::readBoundedInt("age", $stateMeta, 0, 7);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b111;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($blockReplace->getSide(Facing::DOWN)->getId() === BlockLegacyIds::FARMLAND){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
 		return false;
 	}
 
 
-	public function onActivate(Item $item, Player $player = null) : bool{
-		if($this->meta < 7 and $item->getId() === Item::DYE and $item->getDamage() === 0x0F){ //Bonemeal
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($this->age < 7 and $item instanceof Fertilizer){
 			$block = clone $this;
-			$block->meta += mt_rand(2, 5);
-			if($block->meta > 7){
-				$block->meta = 7;
+			$block->age += mt_rand(2, 5);
+			if($block->age > 7){
+				$block->age = 7;
 			}
 
 			$ev = new BlockGrowEvent($this, $block);
 			$ev->call();
 			if(!$ev->isCancelled()){
-				$this->getLevel()->setBlock($this, $ev->getNewState(), true, true);
+				$this->getWorld()->setBlock($this, $ev->getNewState());
 			}
 
-			$item->count--;
+			$item->pop();
 
 			return true;
 		}
@@ -65,8 +85,8 @@ abstract class Crops extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->getId() !== Block::FARMLAND){
-			$this->getLevel()->useBreakOn($this);
+		if($this->getSide(Facing::DOWN)->getId() !== BlockLegacyIds::FARMLAND){
+			$this->getWorld()->useBreakOn($this);
 		}
 	}
 
@@ -75,15 +95,13 @@ abstract class Crops extends Flowable{
 	}
 
 	public function onRandomTick() : void{
-		if(mt_rand(0, 2) === 1){
-			if($this->meta < 0x07){
-				$block = clone $this;
-				++$block->meta;
-				$ev = new BlockGrowEvent($this, $block);
-				$ev->call();
-				if(!$ev->isCancelled()){
-					$this->getLevel()->setBlock($this, $ev->getNewState(), true, true);
-				}
+		if($this->age < 7 and mt_rand(0, 2) === 1){
+			$block = clone $this;
+			++$block->age;
+			$ev = new BlockGrowEvent($this, $block);
+			$ev->call();
+			if(!$ev->isCancelled()){
+				$this->getWorld()->setBlock($this, $ev->getNewState());
 			}
 		}
 	}

src/pocketmine/block/Dandelion.php

@@ -1,67 +0,0 @@
-<?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;
-
-use pocketmine\item\Item;
-use pocketmine\math\Vector3;
-use pocketmine\Player;
-
-class Dandelion extends Flowable{
-
-	protected $id = self::DANDELION;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Dandelion";
-	}
-
-
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$down = $this->getSide(Vector3::SIDE_DOWN);
-		if($down->getId() === Block::GRASS or $down->getId() === Block::DIRT or $down->getId() === Block::FARMLAND){
-			$this->getLevel()->setBlock($blockReplace, $this, true, true);
-
-			return true;
-		}
-
-		return false;
-	}
-
-	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			$this->getLevel()->useBreakOn($this);
-		}
-	}
-
-	public function getFlameEncouragement() : int{
-		return 60;
-	}
-
-	public function getFlammability() : int{
-		return 100;
-	}
-}

src/pocketmine/block/DaylightSensor.php

@@ -23,28 +23,91 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\item\Item;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use function cos;
+use function max;
+use function round;
+use const M_PI;
+
 class DaylightSensor extends Transparent{
+	/** @var BlockIdentifierFlattened */
+	protected $idInfo;
 
-	protected $id = self::DAYLIGHT_SENSOR;
+	/** @var int */
+	protected $power = 0;
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	/** @var bool */
+	protected $inverted = false;
+
+	public function __construct(BlockIdentifierFlattened $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.2, BlockToolType::AXE));
 	}
 
-	public function getName() : string{
-		return "Daylight Sensor";
+	public function getId() : int{
+		return $this->inverted ? $this->idInfo->getSecondId() : parent::getId();
 	}
 
-	public function getHardness() : float{
-		return 0.2;
+	protected function writeStateToMeta() : int{
+		return $this->power;
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->power = BlockDataSerializer::readBoundedInt("power", $stateMeta, 0, 15);
+		$this->inverted = $id === $this->idInfo->getSecondId();
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function isInverted() : bool{
+		return $this->inverted;
+	}
+
+	/**
+	 * @param bool $inverted
+	 *
+	 * @return $this
+	 */
+	public function setInverted(bool $inverted = true) : self{
+		$this->inverted = $inverted;
+		return $this;
 	}
 
 	public function getFuelTime() : int{
 		return 300;
 	}
 
-	public function getToolType() : int{
-		return BlockToolType::TYPE_AXE;
+	protected function recalculateBoundingBox() : ?AxisAlignedBB{
+		return AxisAlignedBB::one()->trim(Facing::UP, 0.5);
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$this->inverted = !$this->inverted;
+		$this->power = $this->recalculatePower();
+		$this->world->setBlock($this, $this);
+		return true;
+	}
+
+	public function onScheduledUpdate() : void{
+		$this->power = $this->recalculatePower();
+		$this->world->setBlock($this, $this);
+		$this->world->scheduleDelayedBlockUpdate($this, 20);
+	}
+
+	private function recalculatePower() : int{
+		$lightLevel = $this->world->getRealBlockSkyLightAt($this->x, $this->y, $this->z);
+		if($this->inverted){
+			return 15 - $lightLevel;
+		}
+
+		$sunAngle = $this->world->getSunAnglePercentage();
+		return max(0, (int) round(15 * cos(($sunAngle + ((($sunAngle < 0.5 ? 0 : 1) - $sunAngle) / 5)) * 2 * M_PI)));
 	}
 
 	//TODO

src/pocketmine/block/DeadBush.php

@@ -24,49 +24,37 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 use function mt_rand;
 
 class DeadBush extends Flowable{
 
-	protected $id = self::DEAD_BUSH;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? BlockBreakInfo::instant(BlockToolType::SHEARS, 1));
 	}
 
-	public function getName() : string{
-		return "Dead Bush";
-	}
-
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		if(!$this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			return parent::place($item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if(!$this->getSide(Facing::DOWN)->isTransparent()){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
 		return false;
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			$this->getLevel()->useBreakOn($this);
+		if($this->getSide(Facing::DOWN)->isTransparent()){
+			$this->getWorld()->useBreakOn($this);
 		}
 	}
 
-	public function getToolType() : int{
-		return BlockToolType::TYPE_SHEARS;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return 1;
-	}
-
 	public function getDrops(Item $item) : array{
-		if(!$this->isCompatibleWithTool($item)){
+		if(!$this->breakInfo->isToolCompatible($item)){
 			return [
-				ItemFactory::get(Item::STICK, 0, mt_rand(0, 2))
+				VanillaItems::STICK()->setCount(mt_rand(0, 2))
 			];
 		}
 

src/pocketmine/block/DetectorRail.php

@@ -25,11 +25,5 @@ namespace pocketmine\block;
 
 class DetectorRail extends RedstoneRail{
 
-	protected $id = self::DETECTOR_RAIL;
-
-	public function getName() : string{
-		return "Detector Rail";
-	}
-
 	//TODO
 }

src/pocketmine/block/DiamondOre.php

@@ -24,37 +24,19 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
+use pocketmine\item\VanillaItems;
 use function mt_rand;
 
-class DiamondOre extends Solid{
+class DiamondOre extends Opaque{
 
-	protected $id = self::DIAMOND_ORE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getHardness() : float{
-		return 3;
-	}
-
-	public function getName() : string{
-		return "Diamond Ore";
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_IRON;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(3.0, BlockToolType::PICKAXE, ToolTier::IRON()->getHarvestLevel()));
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::DIAMOND)
+			VanillaItems::DIAMOND()
 		];
 	}
 

src/pocketmine/block/Dirt.php

@@ -25,39 +25,20 @@ namespace pocketmine\block;
 
 use pocketmine\item\Hoe;
 use pocketmine\item\Item;
-use pocketmine\Player;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
 
-class Dirt extends Solid{
+class Dirt extends Opaque{
 
-	protected $id = self::DIRT;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.5, BlockToolType::SHOVEL));
 	}
 
-	public function getHardness() : float{
-		return 0.5;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_SHOVEL;
-	}
-
-	public function getName() : string{
-		if($this->meta === 1){
-			return "Coarse Dirt";
-		}
-		return "Dirt";
-	}
-
-	public function onActivate(Item $item, Player $player = null) : bool{
-		if($item instanceof Hoe){
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($face === Facing::UP and $item instanceof Hoe){
 			$item->applyDamage(1);
-			if($this->meta === 1){
-				$this->getLevel()->setBlock($this, BlockFactory::get(Block::DIRT), true);
-			}else{
-				$this->getLevel()->setBlock($this, BlockFactory::get(Block::FARMLAND), true);
-			}
+			$this->getWorld()->setBlock($this, VanillaBlocks::FARMLAND());
 
 			return true;
 		}

src/pocketmine/block/Door.php

@@ -23,271 +23,144 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\item\Item;
-use pocketmine\level\sound\DoorSound;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\sound\DoorSound;
 
 
-abstract class Door extends Transparent{
+class Door extends Transparent{
+	/** @var int */
+	protected $facing = Facing::NORTH;
+	/** @var bool */
+	protected $top = false;
+	/** @var bool */
+	protected $hingeRight = false;
+
+	/** @var bool */
+	protected $open = false;
+	/** @var bool */
+	protected $powered = false;
+
+
+	protected function writeStateToMeta() : int{
+		if($this->top){
+			return BlockLegacyMetadata::DOOR_FLAG_TOP |
+				($this->hingeRight ? BlockLegacyMetadata::DOOR_TOP_FLAG_RIGHT : 0) |
+				($this->powered ? BlockLegacyMetadata::DOOR_TOP_FLAG_POWERED : 0);
+		}
+
+		return BlockDataSerializer::writeLegacyHorizontalFacing(Facing::rotateY($this->facing, true)) | ($this->open ? BlockLegacyMetadata::DOOR_BOTTOM_FLAG_OPEN : 0);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->top = $stateMeta & BlockLegacyMetadata::DOOR_FLAG_TOP;
+		if($this->top){
+			$this->hingeRight = ($stateMeta & BlockLegacyMetadata::DOOR_TOP_FLAG_RIGHT) !== 0;
+			$this->powered = ($stateMeta & BlockLegacyMetadata::DOOR_TOP_FLAG_POWERED) !== 0;
+		}else{
+			$this->facing = Facing::rotateY(BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03), false);
+			$this->open = ($stateMeta & BlockLegacyMetadata::DOOR_BOTTOM_FLAG_OPEN) !== 0;
+		}
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
+
+	public function readStateFromWorld() : void{
+		parent::readStateFromWorld();
+
+		//copy door properties from other half
+		$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);
+		if($other instanceof Door and $other->isSameType($this)){
+			if($this->top){
+				$this->facing = $other->facing;
+				$this->open = $other->open;
+			}else{
+				$this->hingeRight = $other->hingeRight;
+				$this->powered = $other->powered;
+			}
+		}
+	}
 
 	public function isSolid() : bool{
 		return false;
 	}
 
-	private function getFullDamage(){
-		$damage = $this->getDamage();
-		$isUp = ($damage & 0x08) > 0;
-
-		if($isUp){
-			$down = $this->getSide(Vector3::SIDE_DOWN)->getDamage();
-			$up = $damage;
-		}else{
-			$down = $damage;
-			$up = $this->getSide(Vector3::SIDE_UP)->getDamage();
-		}
-
-		$isRight = ($up & 0x01) > 0;
-
-		return $down & 0x07 | ($isUp ? 8 : 0) | ($isRight ? 0x10 : 0);
-	}
-
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-
-		$f = 0.1875;
-		$damage = $this->getFullDamage();
-
-		$bb = new AxisAlignedBB(
-			$this->x,
-			$this->y,
-			$this->z,
-			$this->x + 1,
-			$this->y + 2,
-			$this->z + 1
-		);
-
-		$j = $damage & 0x03;
-		$isOpen = (($damage & 0x04) > 0);
-		$isRight = (($damage & 0x10) > 0);
-
-		if($j === 0){
-			if($isOpen){
-				if(!$isRight){
-					$bb->setBounds(
-						$this->x,
-						$this->y,
-						$this->z,
-						$this->x + 1,
-						$this->y + 1,
-						$this->z + $f
-					);
-				}else{
-					$bb->setBounds(
-						$this->x,
-						$this->y,
-						$this->z + 1 - $f,
-						$this->x + 1,
-						$this->y + 1,
-						$this->z + 1
-					);
-				}
-			}else{
-				$bb->setBounds(
-					$this->x,
-					$this->y,
-					$this->z,
-					$this->x + $f,
-					$this->y + 1,
-					$this->z + 1
-				);
-			}
-		}elseif($j === 1){
-			if($isOpen){
-				if(!$isRight){
-					$bb->setBounds(
-						$this->x + 1 - $f,
-						$this->y,
-						$this->z,
-						$this->x + 1,
-						$this->y + 1,
-						$this->z + 1
-					);
-				}else{
-					$bb->setBounds(
-						$this->x,
-						$this->y,
-						$this->z,
-						$this->x + $f,
-						$this->y + 1,
-						$this->z + 1
-					);
-				}
-			}else{
-				$bb->setBounds(
-					$this->x,
-					$this->y,
-					$this->z,
-					$this->x + 1,
-					$this->y + 1,
-					$this->z + $f
-				);
-			}
-		}elseif($j === 2){
-			if($isOpen){
-				if(!$isRight){
-					$bb->setBounds(
-						$this->x,
-						$this->y,
-						$this->z + 1 - $f,
-						$this->x + 1,
-						$this->y + 1,
-						$this->z + 1
-					);
-				}else{
-					$bb->setBounds(
-						$this->x,
-						$this->y,
-						$this->z,
-						$this->x + 1,
-						$this->y + 1,
-						$this->z + $f
-					);
-				}
-			}else{
-				$bb->setBounds(
-					$this->x + 1 - $f,
-					$this->y,
-					$this->z,
-					$this->x + 1,
-					$this->y + 1,
-					$this->z + 1
-				);
-			}
-		}elseif($j === 3){
-			if($isOpen){
-				if(!$isRight){
-					$bb->setBounds(
-						$this->x,
-						$this->y,
-						$this->z,
-						$this->x + $f,
-						$this->y + 1,
-						$this->z + 1
-					);
-				}else{
-					$bb->setBounds(
-						$this->x + 1 - $f,
-						$this->y,
-						$this->z,
-						$this->x + 1,
-						$this->y + 1,
-						$this->z + 1
-					);
-				}
-			}else{
-				$bb->setBounds(
-					$this->x,
-					$this->y,
-					$this->z + 1 - $f,
-					$this->x + 1,
-					$this->y + 1,
-					$this->z + 1
-				);
-			}
-		}
-
-		return $bb;
+		return AxisAlignedBB::one()
+			->extend(Facing::UP, 1)
+			->trim($this->open ? Facing::rotateY($this->facing, !$this->hingeRight) : $this->facing, 13 / 16);
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->getId() === self::AIR){ //Replace with common break method
-			$this->getLevel()->setBlock($this, BlockFactory::get(Block::AIR), false);
-			if($this->getSide(Vector3::SIDE_UP) instanceof Door){
-				$this->getLevel()->setBlock($this->getSide(Vector3::SIDE_UP), BlockFactory::get(Block::AIR), false);
-			}
+		if($this->getSide(Facing::DOWN)->getId() === BlockLegacyIds::AIR){ //Replace with common break method
+			$this->getWorld()->useBreakOn($this); //this will delete both halves if they exist
 		}
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		if($face === Vector3::SIDE_UP){
-			$blockUp = $this->getSide(Vector3::SIDE_UP);
-			$blockDown = $this->getSide(Vector3::SIDE_DOWN);
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($face === Facing::UP){
+			$blockUp = $this->getSide(Facing::UP);
+			$blockDown = $this->getSide(Facing::DOWN);
 			if(!$blockUp->canBeReplaced() or $blockDown->isTransparent()){
 				return false;
 			}
-			$direction = $player instanceof Player ? $player->getDirection() : 0;
-			$faces = [
-				0 => 3,
-				1 => 4,
-				2 => 2,
-				3 => 5
-			];
-			$next = $this->getSide($faces[($direction + 2) % 4]);
-			$next2 = $this->getSide($faces[$direction]);
-			$metaUp = 0x08;
-			if($next->getId() === $this->getId() or (!$next2->isTransparent() and $next->isTransparent())){ //Door hinge
-				$metaUp |= 0x01;
+
+			if($player !== null){
+				$this->facing = $player->getHorizontalFacing();
 			}
 
-			$this->setDamage($player->getDirection() & 0x03);
-			$this->getLevel()->setBlock($blockReplace, $this, true, true); //Bottom
-			$this->getLevel()->setBlock($blockUp, BlockFactory::get($this->getId(), $metaUp), true); //Top
+			$next = $this->getSide(Facing::rotateY($this->facing, false));
+			$next2 = $this->getSide(Facing::rotateY($this->facing, true));
+
+			if($next->isSameType($this) or (!$next2->isTransparent() and $next->isTransparent())){ //Door hinge
+				$this->hingeRight = true;
+			}
+
+			$topHalf = clone $this;
+			$topHalf->top = true;
+
+			$tx->addBlock($blockReplace, $this)->addBlock($blockUp, $topHalf);
 			return true;
 		}
 
 		return false;
 	}
 
-	public function onActivate(Item $item, Player $player = null) : bool{
-		if(($this->getDamage() & 0x08) === 0x08){ //Top
-			$down = $this->getSide(Vector3::SIDE_DOWN);
-			if($down->getId() === $this->getId()){
-				$meta = $down->getDamage() ^ 0x04;
-				$this->level->setBlock($down, BlockFactory::get($this->getId(), $meta), true);
-				$this->level->addSound(new DoorSound($this));
-				return true;
-			}
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$this->open = !$this->open;
 
-			return false;
-		}else{
-			$this->meta ^= 0x04;
-			$this->level->setBlock($this, $this, true);
-			$this->level->addSound(new DoorSound($this));
+		$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);
+		if($other instanceof Door and $other->isSameType($this)){
+			$other->open = $this->open;
+			$this->world->setBlock($other, $other);
 		}
 
+		$this->world->setBlock($this, $this);
+		$this->world->addSound($this, new DoorSound());
+
 		return true;
 	}
 
-	public function getVariantBitmask() : int{
-		return 0;
-	}
-
-	public function getDropsForCompatibleTool(Item $item) : array{
-		if(($this->meta & 0x08) === 0){ //bottom half only
-			return parent::getDropsForCompatibleTool($item);
+	public function getDrops(Item $item) : array{
+		if(!$this->top){
+			return parent::getDrops($item);
 		}
 
 		return [];
 	}
 
-	public function isAffectedBySilkTouch() : bool{
-		return false;
-	}
-
 	public function getAffectedBlocks() : array{
-		if(($this->getDamage() & 0x08) === 0x08){
-			$down = $this->getSide(Vector3::SIDE_DOWN);
-			if($down->getId() === $this->getId()){
-				return [$this, $down];
-			}
-		}else{
-			$up = $this->getSide(Vector3::SIDE_UP);
-			if($up->getId() === $this->getId()){
-				return [$this, $up];
-			}
+		$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);
+		if($other->isSameType($this)){
+			return [$this, $other];
 		}
-
 		return parent::getAffectedBlocks();
 	}
 }

src/pocketmine/block/DoublePlant.php

@@ -24,42 +24,38 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
-use function mt_rand;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
 class DoublePlant extends Flowable{
-	public const BITFLAG_TOP = 0x08;
 
-	protected $id = self::DOUBLE_PLANT;
+	/** @var bool */
+	protected $top = false;
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? BlockBreakInfo::instant());
 	}
 
-	public function canBeReplaced() : bool{
-		return $this->getVariant() === 2 or $this->getVariant() === 3; //grass or fern
+	protected function writeStateToMeta() : int{
+		return ($this->top ? BlockLegacyMetadata::DOUBLE_PLANT_FLAG_TOP : 0);
 	}
 
-	public function getName() : string{
-		static $names = [
-			0 => "Sunflower",
-			1 => "Lilac",
-			2 => "Double Tallgrass",
-			3 => "Large Fern",
-			4 => "Rose Bush",
-			5 => "Peony"
-		];
-		return $names[$this->getVariant()] ?? "";
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->top = ($stateMeta & BlockLegacyMetadata::DOUBLE_PLANT_FLAG_TOP) !== 0;
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$id = $blockReplace->getSide(Vector3::SIDE_DOWN)->getId();
-		if(($id === Block::GRASS or $id === Block::DIRT) and $blockReplace->getSide(Vector3::SIDE_UP)->canBeReplaced()){
-			$this->getLevel()->setBlock($blockReplace, $this, false, false);
-			$this->getLevel()->setBlock($blockReplace->getSide(Vector3::SIDE_UP), BlockFactory::get($this->id, $this->meta | self::BITFLAG_TOP), false, false);
+	public function getStateBitmask() : int{
+		return 0b1000;
+	}
 
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$id = $blockReplace->getSide(Facing::DOWN)->getId();
+		if(($id === BlockLegacyIds::GRASS or $id === BlockLegacyIds::DIRT) and $blockReplace->getSide(Facing::UP)->canBeReplaced()){
+			$top = clone $this;
+			$top->top = true;
+			$tx->addBlock($blockReplace, $this)->addBlock($blockReplace->getSide(Facing::UP), $top);
 			return true;
 		}
 
@@ -71,56 +67,28 @@ class DoublePlant extends Flowable{
 	 * @return bool
 	 */
 	public function isValidHalfPlant() : bool{
-		if($this->meta & self::BITFLAG_TOP){
-			$other = $this->getSide(Vector3::SIDE_DOWN);
-		}else{
-			$other = $this->getSide(Vector3::SIDE_UP);
-		}
+		$other = $this->getSide($this->top ? Facing::DOWN : Facing::UP);
 
 		return (
-			$other->getId() === $this->getId() and
-			$other->getVariant() === $this->getVariant() and
-			($other->getDamage() & self::BITFLAG_TOP) !== ($this->getDamage() & self::BITFLAG_TOP)
+			$other instanceof DoublePlant and
+			$other->isSameType($this) and
+			$other->top !== $this->top
 		);
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->isValidHalfPlant() or (($this->meta & self::BITFLAG_TOP) === 0 and $this->getSide(Vector3::SIDE_DOWN)->isTransparent())){
-			$this->getLevel()->useBreakOn($this);
+		if(!$this->isValidHalfPlant() or (!$this->top and $this->getSide(Facing::DOWN)->isTransparent())){
+			$this->getWorld()->useBreakOn($this);
 		}
 	}
 
-	public function getVariantBitmask() : int{
-		return 0x07;
-	}
-
-	public function getToolType() : int{
-		return ($this->getVariant() === 2 or $this->getVariant() === 3) ? BlockToolType::TYPE_SHEARS : BlockToolType::TYPE_NONE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return ($this->getVariant() === 2 or $this->getVariant() === 3) ? 1 : 0; //only grass or fern require shears
-	}
-
 	public function getDrops(Item $item) : array{
-		if($this->meta & self::BITFLAG_TOP){
-			if($this->isCompatibleWithTool($item)){
-				return parent::getDrops($item);
-			}
-
-			if(mt_rand(0, 24) === 0){
-				return [
-					ItemFactory::get(Item::SEEDS)
-				];
-			}
-		}
-
-		return [];
+		return $this->top ? parent::getDrops($item) : [];
 	}
 
 	public function getAffectedBlocks() : array{
 		if($this->isValidHalfPlant()){
-			return [$this, $this->getSide(($this->meta & self::BITFLAG_TOP) !== 0 ? Vector3::SIDE_DOWN : Vector3::SIDE_UP)];
+			return [$this, $this->getSide($this->top ? Facing::DOWN : Facing::UP)];
 		}
 
 		return parent::getAffectedBlocks();

src/pocketmine/block/DoubleTallGrass.php

@@ -24,31 +24,25 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\TieredTool;
+use pocketmine\item\VanillaItems;
+use function mt_rand;
 
-class IronDoor extends Door{
+class DoubleTallGrass extends DoublePlant{
 
-	protected $id = self::IRON_DOOR_BLOCK;
-
-	protected $itemId = Item::IRON_DOOR;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? BlockBreakInfo::instant(BlockToolType::SHEARS, 1));
 	}
 
-	public function getName() : string{
-		return "Iron Door";
+	public function canBeReplaced() : bool{
+		return true;
 	}
 
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
-	}
-
-	public function getHardness() : float{
-		return 5;
+	public function getDrops(Item $item) : array{
+		if($this->top and !$this->breakInfo->isToolCompatible($item) and mt_rand(0, 7) === 0){
+			return [
+				VanillaItems::WHEAT_SEEDS()
+			];
+		}
+		return parent::getDrops($item);
 	}
 }

src/pocketmine/block/DragonEgg.php

@@ -0,0 +1,86 @@
+<?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;
+
+use pocketmine\block\utils\Fallable;
+use pocketmine\block\utils\FallableTrait;
+use pocketmine\event\block\BlockTeleportEvent;
+use pocketmine\item\Item;
+use pocketmine\item\ToolTier;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\particle\DragonEggTeleportParticle;
+use pocketmine\world\World;
+use function max;
+use function min;
+use function mt_rand;
+
+class DragonEgg extends Transparent implements Fallable{
+	use FallableTrait;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(3.0, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel()));
+	}
+
+	public function getLightLevel() : int{
+		return 1;
+	}
+
+	public function tickFalling() : ?Block{
+		return null;
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$this->teleport();
+		return true;
+	}
+
+	public function onAttack(Item $item, int $face, ?Player $player = null) : bool{
+		$this->teleport();
+		return true;
+	}
+
+	public function teleport() : void{
+		for($tries = 0; $tries < 16; ++$tries){
+			$block = $this->world->getBlockAt(
+				$this->x + mt_rand(-16, 16),
+				max(0, min(World::Y_MAX - 1, $this->y + mt_rand(-8, 8))),
+				$this->z + mt_rand(-16, 16)
+			);
+			if($block instanceof Air){
+				$ev = new BlockTeleportEvent($this, $block);
+				$ev->call();
+				if($ev->isCancelled()){
+					break;
+				}else{
+					$block = $ev->getTo();
+				}
+				$this->world->addParticle($this, new DragonEggTeleportParticle($this->x - $block->x, $this->y - $block->y, $this->z - $block->z));
+				$this->world->setBlock($this, VanillaBlocks::AIR());
+				$this->world->setBlock($block, $this);
+				break;
+			}
+		}
+	}
+}

src/pocketmine/block/DriedKelp.php

@@ -23,15 +23,17 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-class LitRedstoneLamp extends RedstoneLamp{
+class DriedKelp extends Opaque{
 
-	protected $id = self::LIT_REDSTONE_LAMP;
-
-	public function getName() : string{
-		return "Lit Redstone Lamp";
+	public function getFlameEncouragement() : int{
+		return 30;
 	}
 
-	public function getLightLevel() : int{
-		return 15;
+	public function getFlammability() : int{
+		return 60;
+	}
+
+	public function getFuelTime() : int{
+		return 4000;
 	}
 }

src/pocketmine/block/Element.php

@@ -0,0 +1,62 @@
+<?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;
+
+class Element extends Opaque{
+
+	/** @var int */
+	private $atomicWeight;
+	/** @var int */
+	private $group;
+	/** @var string */
+	private $symbol;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, BlockBreakInfo $breakInfo, string $symbol, int $atomicWeight, int $group){
+		parent::__construct($idInfo, $name, $breakInfo);
+		$this->atomicWeight = $atomicWeight;
+		$this->group = $group;
+		$this->symbol = $symbol;
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getAtomicWeight() : int{
+		return $this->atomicWeight;
+	}
+
+	/**
+	 * @return int
+	 */
+	public function getGroup() : int{
+		return $this->group;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getSymbol() : string{
+		return $this->symbol;
+	}
+}

src/pocketmine/block/Emerald.php

@@ -1,51 +0,0 @@
-<?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;
-
-use pocketmine\item\TieredTool;
-
-class Emerald extends Solid{
-
-	protected $id = self::EMERALD_BLOCK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getHardness() : float{
-		return 5;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_IRON;
-	}
-
-	public function getName() : string{
-		return "Emerald Block";
-	}
-}

src/pocketmine/block/EmeraldOre.php

@@ -24,37 +24,19 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
+use pocketmine\item\VanillaItems;
 use function mt_rand;
 
-class EmeraldOre extends Solid{
+class EmeraldOre extends Opaque{
 
-	protected $id = self::EMERALD_ORE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Emerald Ore";
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_IRON;
-	}
-
-	public function getHardness() : float{
-		return 3;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(3.0, BlockToolType::PICKAXE, ToolTier::IRON()->getHarvestLevel()));
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::EMERALD)
+			VanillaItems::EMERALD()
 		];
 	}
 

src/pocketmine/block/EnchantingTable.php

@@ -25,53 +25,27 @@ namespace pocketmine\block;
 
 use pocketmine\inventory\EnchantInventory;
 use pocketmine\item\Item;
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
-use pocketmine\tile\EnchantTable as TileEnchantTable;
-use pocketmine\tile\Tile;
+use pocketmine\player\Player;
 
 class EnchantingTable extends Transparent{
 
-	protected $id = self::ENCHANTING_TABLE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(5.0, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel(), 6000.0));
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
-
-		Tile::createTile(Tile::ENCHANT_TABLE, $this->getLevel(), TileEnchantTable::createNBT($this, $face, $item, $player));
-
-		return true;
+	protected function recalculateBoundingBox() : ?AxisAlignedBB{
+		return AxisAlignedBB::one()->trim(Facing::UP, 0.25);
 	}
 
-	public function getHardness() : float{
-		return 5;
-	}
-
-	public function getBlastResistance() : float{
-		return 6000;
-	}
-
-	public function getName() : string{
-		return "Enchanting Table";
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
-	}
-
-	public function onActivate(Item $item, Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player instanceof Player){
 			//TODO lock
 
-			$player->addWindow(new EnchantInventory($this));
+			$player->setCurrentWindow(new EnchantInventory($this));
 		}
 
 		return true;

src/pocketmine/block/EndPortalFrame.php

@@ -23,46 +23,50 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
-class EndPortalFrame extends Solid{
+class EndPortalFrame extends Opaque{
 
-	protected $id = self::END_PORTAL_FRAME;
+	/** @var int */
+	protected $facing = Facing::NORTH;
+	/** @var bool */
+	protected $eye = false;
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? BlockBreakInfo::indestructible());
+	}
+
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeLegacyHorizontalFacing($this->facing) | ($this->eye ? BlockLegacyMetadata::END_PORTAL_FRAME_FLAG_EYE : 0);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03);
+		$this->eye = ($stateMeta & BlockLegacyMetadata::END_PORTAL_FRAME_FLAG_EYE) !== 0;
+	}
+
+	public function getStateBitmask() : int{
+		return 0b111;
 	}
 
 	public function getLightLevel() : int{
 		return 1;
 	}
 
-	public function getName() : string{
-		return "End Portal Frame";
-	}
-
-	public function getHardness() : float{
-		return -1;
-	}
-
-	public function getBlastResistance() : float{
-		return 18000000;
-	}
-
-	public function isBreakable(Item $item) : bool{
-		return false;
-	}
-
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
+		return AxisAlignedBB::one()->trim(Facing::UP, 3 / 16);
+	}
 
-		return new AxisAlignedBB(
-			$this->x,
-			$this->y,
-			$this->z,
-			$this->x + 1,
-			$this->y + (($this->getDamage() & 0x04) > 0 ? 1 : 0.8125),
-			$this->z + 1
-		);
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player !== null){
+			$this->facing = Facing::opposite($player->getHorizontalFacing());
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 }

src/pocketmine/block/EndRod.php

@@ -23,34 +23,51 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
 class EndRod extends Flowable{
 
-	protected $id = Block::END_ROD;
+	/** @var int */
+	protected $facing = Facing::DOWN;
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? BlockBreakInfo::instant());
 	}
 
-	public function getName() : string{
-		return "End Rod";
+	protected function writeStateToMeta() : int{
+		$result = BlockDataSerializer::writeFacing($this->facing);
+		if(Facing::axis($this->facing) !== Facing::AXIS_Y){
+			$result ^= 1; //TODO: in PC this is always the same as facing, just PE is stupid
+		}
+
+		return $result;
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		if($face === Vector3::SIDE_UP or $face === Vector3::SIDE_DOWN){
-			$this->meta = $face;
-		}else{
-			$this->meta = $face ^ 0x01;
-		}
-		if($blockClicked instanceof EndRod and $blockClicked->getDamage() === $this->meta){
-			$this->meta ^= 0x01;
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		if($stateMeta !== 0 and $stateMeta !== 1){
+			$stateMeta ^= 1;
 		}
 
-		return $this->level->setBlock($blockReplace, $this, true, true);
+		$this->facing = BlockDataSerializer::readFacing($stateMeta);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b111;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$this->facing = $face;
+		if($blockClicked instanceof EndRod and $blockClicked->facing === $this->facing){
+			$this->facing = Facing::opposite($face);
+		}
+
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
 	public function isSolid() : bool{
@@ -62,43 +79,15 @@ class EndRod extends Flowable{
 	}
 
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-		$m = $this->meta & ~0x01;
-		$width = 0.375;
+		$myAxis = Facing::axis($this->facing);
 
-		switch($m){
-			case 0x00: //up/down
-				return new AxisAlignedBB(
-					$this->x + $width,
-					$this->y,
-					$this->z + $width,
-					$this->x + 1 - $width,
-					$this->y + 1,
-					$this->z + 1 - $width
-				);
-			case 0x02: //north/south
-				return new AxisAlignedBB(
-					$this->x,
-					$this->y + $width,
-					$this->z + $width,
-					$this->x + 1,
-					$this->y + 1 - $width,
-					$this->z + 1 - $width
-				);
-			case 0x04: //east/west
-				return new AxisAlignedBB(
-					$this->x + $width,
-					$this->y + $width,
-					$this->z,
-					$this->x + 1 - $width,
-					$this->y + 1 - $width,
-					$this->z + 1
-				);
+		$bb = AxisAlignedBB::one();
+		foreach([Facing::AXIS_Y, Facing::AXIS_Z, Facing::AXIS_X] as $axis){
+			if($axis === $myAxis){
+				continue;
+			}
+			$bb->squash($axis, 6 / 16);
 		}
-
-		return null;
-	}
-
-	public function getVariantBitmask() : int{
-		return 0;
+		return $bb;
 	}
 }

src/pocketmine/block/EndStone.php

@@ -1,51 +0,0 @@
-<?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;
-
-use pocketmine\item\TieredTool;
-
-class EndStone extends Solid{
-
-	protected $id = self::END_STONE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "End Stone";
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
-	}
-
-	public function getHardness() : float{
-		return 3;
-	}
-}

src/pocketmine/block/EnderChest.php

@@ -23,75 +23,60 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\tile\EnderChest as TileEnderChest;
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
+use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
-use pocketmine\tile\EnderChest as TileEnderChest;
-use pocketmine\tile\Tile;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
-class EnderChest extends Chest{
+class EnderChest extends Transparent{
 
-	protected $id = self::ENDER_CHEST;
+	/** @var int */
+	protected $facing = Facing::NORTH;
 
-	public function getHardness() : float{
-		return 22.5;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(22.5, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel(), 3000.0));
 	}
 
-	public function getBlastResistance() : float{
-		return 3000;
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeHorizontalFacing($this->facing);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readHorizontalFacing($stateMeta);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b111;
 	}
 
 	public function getLightLevel() : int{
 		return 7;
 	}
 
-	public function getName() : string{
-		return "Ender Chest";
+	protected function recalculateBoundingBox() : ?AxisAlignedBB{
+		//these are slightly bigger than in PC
+		return AxisAlignedBB::one()->contract(0.025, 0, 0.025)->trim(Facing::UP, 0.05);
 	}
 
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player !== null){
+			$this->facing = Facing::opposite($player->getHorizontalFacing());
+		}
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
-	}
-
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$faces = [
-			0 => 4,
-			1 => 2,
-			2 => 5,
-			3 => 3
-		];
-
-		$this->meta = $faces[$player instanceof Player ? $player->getDirection() : 0];
-
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
-		Tile::createTile(Tile::ENDER_CHEST, $this->getLevel(), TileEnderChest::createNBT($this, $face, $item, $player));
-
-		return true;
-	}
-
-	public function onActivate(Item $item, Player $player = null) : bool{
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player instanceof Player){
-
-			$t = $this->getLevel()->getTile($this);
-			$enderChest = null;
-			if($t instanceof TileEnderChest){
-				$enderChest = $t;
-			}else{
-				$enderChest = Tile::createTile(Tile::ENDER_CHEST, $this->getLevel(), TileEnderChest::createNBT($this));
+			$enderChest = $this->getWorld()->getTile($this);
+			if($enderChest instanceof TileEnderChest and $this->getSide(Facing::UP)->isTransparent()){
+				$player->getEnderChestInventory()->setHolderPosition($enderChest);
+				$player->setCurrentWindow($player->getEnderChestInventory());
 			}
-
-			if(!$this->getSide(Vector3::SIDE_UP)->isTransparent()){
-				return true;
-			}
-
-			$player->getEnderChestInventory()->setHolderPosition($enderChest);
-			$player->addWindow($player->getEnderChestInventory());
 		}
 
 		return true;
@@ -99,11 +84,7 @@ class EnderChest extends Chest{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::OBSIDIAN, 0, 8)
+			VanillaBlocks::OBSIDIAN()->asItem()->setCount(8)
 		];
 	}
-
-	public function getFuelTime() : int{
-		return 0;
-	}
 }

src/pocketmine/block/Farmland.php

@@ -23,46 +23,39 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
 use pocketmine\math\AxisAlignedBB;
-use pocketmine\math\Vector3;
+use pocketmine\math\Facing;
 
 class Farmland extends Transparent{
 
-	protected $id = self::FARMLAND;
+	/** @var int */
+	protected $wetness = 0; //"moisture" blockstate property in PC
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.6, BlockToolType::SHOVEL));
 	}
 
-	public function getName() : string{
-		return "Farmland";
+	protected function writeStateToMeta() : int{
+		return $this->wetness;
 	}
 
-	public function getHardness() : float{
-		return 0.6;
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->wetness = BlockDataSerializer::readBoundedInt("wetness", $stateMeta, 0, 7);
 	}
 
-	public function getToolType() : int{
-		return BlockToolType::TYPE_SHOVEL;
+	public function getStateBitmask() : int{
+		return 0b111;
 	}
 
-
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-		return new AxisAlignedBB(
-			$this->x,
-			$this->y,
-			$this->z,
-			$this->x + 1,
-			$this->y + 1, //TODO: this should be 0.9375, but MCPE currently treats them as a full block (https://bugs.mojang.com/browse/MCPE-12109)
-			$this->z + 1
-		);
+		return AxisAlignedBB::one(); //TODO: this should be trimmed at the top by 1/16, but MCPE currently treats them as a full block (https://bugs.mojang.com/browse/MCPE-12109)
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_UP)->isSolid()){
-			$this->level->setBlock($this, BlockFactory::get(Block::DIRT), true);
+		if($this->getSide(Facing::UP)->isSolid()){
+			$this->world->setBlock($this, VanillaBlocks::DIRT());
 		}
 	}
 
@@ -72,15 +65,15 @@ class Farmland extends Transparent{
 
 	public function onRandomTick() : void{
 		if(!$this->canHydrate()){
-			if($this->meta > 0){
-				$this->meta--;
-				$this->level->setBlock($this, $this, false, false);
+			if($this->wetness > 0){
+				$this->wetness--;
+				$this->world->setBlock($this, $this, false);
 			}else{
-				$this->level->setBlock($this, BlockFactory::get(Block::DIRT), false, true);
+				$this->world->setBlock($this, VanillaBlocks::DIRT());
 			}
-		}elseif($this->meta < 7){
-			$this->meta = 7;
-			$this->level->setBlock($this, $this, false, false);
+		}elseif($this->wetness < 7){
+			$this->wetness = 7;
+			$this->world->setBlock($this, $this, false);
 		}
 	}
 
@@ -91,8 +84,7 @@ class Farmland extends Transparent{
 		for($y = $start->y; $y <= $end->y; ++$y){
 			for($z = $start->z; $z <= $end->z; ++$z){
 				for($x = $start->x; $x <= $end->x; ++$x){
-					$id = $this->level->getBlockIdAt($x, $y, $z);
-					if($id === Block::STILL_WATER or $id === Block::FLOWING_WATER){
+					if($this->world->getBlockAt($x, $y, $z) instanceof Water){
 						return true;
 					}
 				}
@@ -104,7 +96,7 @@ class Farmland extends Transparent{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::DIRT)
+			VanillaBlocks::DIRT()->asItem()
 		];
 	}
 
@@ -112,7 +104,7 @@ class Farmland extends Transparent{
 		return false;
 	}
 
-	public function getPickedItem() : Item{
-		return ItemFactory::get(Item::DIRT);
+	public function getPickedItem(bool $addUserData = false) : Item{
+		return VanillaBlocks::DIRT()->asItem();
 	}
 }

src/pocketmine/block/Fence.php

@@ -24,29 +24,40 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\math\AxisAlignedBB;
-use pocketmine\math\Vector3;
+use pocketmine\math\Facing;
 
-abstract class Fence extends Transparent{
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
+class Fence extends Transparent{
+	/** @var bool[] facing => dummy */
+	protected $connections = [];
 
 	public function getThickness() : float{
 		return 0.25;
 	}
 
+	public function readStateFromWorld() : void{
+		parent::readStateFromWorld();
+
+		foreach(Facing::HORIZONTAL as $facing){
+			$block = $this->getSide($facing);
+			if($block instanceof static or $block instanceof FenceGate or ($block->isSolid() and !$block->isTransparent())){
+				$this->connections[$facing] = true;
+			}else{
+				unset($this->connections[$facing]);
+			}
+		}
+	}
+
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
 		$width = 0.5 - $this->getThickness() / 2;
 
-		return new AxisAlignedBB(
-			$this->x + ($this->canConnect($this->getSide(Vector3::SIDE_WEST)) ? 0 : $width),
-			$this->y,
-			$this->z + ($this->canConnect($this->getSide(Vector3::SIDE_NORTH)) ? 0 : $width),
-			$this->x + 1 - ($this->canConnect($this->getSide(Vector3::SIDE_EAST)) ? 0 : $width),
-			$this->y + 1.5,
-			$this->z + 1 - ($this->canConnect($this->getSide(Vector3::SIDE_SOUTH)) ? 0 : $width)
-		);
+		$bb = AxisAlignedBB::one()
+			->extend(Facing::UP, 0.5);
+		foreach(Facing::HORIZONTAL as $facing){
+			if(!isset($this->connections[$facing])){
+				$bb->trim($facing, $width);
+			}
+		}
+		return $bb;
 	}
 
 	protected function recalculateCollisionBoxes() : array{
@@ -55,54 +66,39 @@ abstract class Fence extends Transparent{
 		/** @var AxisAlignedBB[] $bbs */
 		$bbs = [];
 
-		$connectWest = $this->canConnect($this->getSide(Vector3::SIDE_WEST));
-		$connectEast = $this->canConnect($this->getSide(Vector3::SIDE_EAST));
+		$connectWest = isset($this->connections[Facing::WEST]);
+		$connectEast = isset($this->connections[Facing::EAST]);
 
 		if($connectWest or $connectEast){
 			//X axis (west/east)
-			$bbs[] = new AxisAlignedBB(
-				$this->x + ($connectWest ? 0 : $inset),
-				$this->y,
-				$this->z + $inset,
-				$this->x + 1 - ($connectEast ? 0 : $inset),
-				$this->y + 1.5,
-				$this->z + 1 - $inset
-			);
+			$bbs[] = AxisAlignedBB::one()
+				->squash(Facing::AXIS_Z, $inset)
+				->extend(Facing::UP, 0.5)
+				->trim(Facing::WEST, $connectWest ? 0 : $inset)
+				->trim(Facing::EAST, $connectEast ? 0 : $inset);
 		}
 
-		$connectNorth = $this->canConnect($this->getSide(Vector3::SIDE_NORTH));
-		$connectSouth = $this->canConnect($this->getSide(Vector3::SIDE_SOUTH));
+		$connectNorth = isset($this->connections[Facing::NORTH]);
+		$connectSouth = isset($this->connections[Facing::SOUTH]);
 
 		if($connectNorth or $connectSouth){
 			//Z axis (north/south)
-			$bbs[] = new AxisAlignedBB(
-				$this->x + $inset,
-				$this->y,
-				$this->z + ($connectNorth ? 0 : $inset),
-				$this->x + 1 - $inset,
-				$this->y + 1.5,
-				$this->z + 1 - ($connectSouth ? 0 : $inset)
-			);
+			$bbs[] = AxisAlignedBB::one()
+				->squash(Facing::AXIS_X, $inset)
+				->extend(Facing::UP, 0.5)
+				->trim(Facing::NORTH, $connectNorth ? 0 : $inset)
+				->trim(Facing::SOUTH, $connectSouth ? 0 : $inset);
 		}
 
 		if(empty($bbs)){
 			//centre post AABB (only needed if not connected on any axis - other BBs overlapping will do this if any connections are made)
 			return [
-				new AxisAlignedBB(
-					$this->x + $inset,
-					$this->y,
-					$this->z + $inset,
-					$this->x + 1 - $inset,
-					$this->y + 1.5,
-					$this->z + 1 - $inset
-				)
+				AxisAlignedBB::one()
+					->extend(Facing::UP, 0.5)
+					->contract($inset, 0, $inset)
 			];
 		}
 
 		return $bbs;
 	}
-
-	public function canConnect(Block $block){
-		return $block instanceof static or $block instanceof FenceGate or ($block->isSolid() and !$block->isTransparent());
-	}
 }

src/pocketmine/block/FenceGate.php

@@ -23,71 +23,87 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\item\Item;
-use pocketmine\level\sound\DoorSound;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use pocketmine\world\sound\DoorSound;
 
 class FenceGate extends Transparent{
+	/** @var bool */
+	protected $open = false;
+	/** @var int */
+	protected $facing = Facing::NORTH;
+	/** @var bool */
+	protected $inWall = false;
 
-	public function getHardness() : float{
-		return 2;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(2.0, BlockToolType::AXE));
 	}
 
-	public function getToolType() : int{
-		return BlockToolType::TYPE_AXE;
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeLegacyHorizontalFacing($this->facing) |
+			($this->open ? BlockLegacyMetadata::FENCE_GATE_FLAG_OPEN : 0) |
+			($this->inWall ? BlockLegacyMetadata::FENCE_GATE_FLAG_IN_WALL : 0);
 	}
 
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readLegacyHorizontalFacing($stateMeta & 0x03);
+		$this->open = ($stateMeta & BlockLegacyMetadata::FENCE_GATE_FLAG_OPEN) !== 0;
+		$this->inWall = ($stateMeta & BlockLegacyMetadata::FENCE_GATE_FLAG_IN_WALL) !== 0;
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
+	}
 
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-
-		if(($this->getDamage() & 0x04) > 0){
+		if($this->open){
 			return null;
 		}
 
-		$i = ($this->getDamage() & 0x03);
-		if($i === 2 or $i === 0){
-			return new AxisAlignedBB(
-				$this->x,
-				$this->y,
-				$this->z + 0.375,
-				$this->x + 1,
-				$this->y + 1.5,
-				$this->z + 0.625
-			);
-		}else{
-			return new AxisAlignedBB(
-				$this->x + 0.375,
-				$this->y,
-				$this->z,
-				$this->x + 0.625,
-				$this->y + 1.5,
-				$this->z + 1
-			);
-		}
+		return AxisAlignedBB::one()->extend(Facing::UP, 0.5)->squash(Facing::axis($this->facing), 6 / 16);
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$this->meta = ($player instanceof Player ? ($player->getDirection() - 1) & 0x03 : 0);
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
-
-		return true;
+	private function checkInWall() : bool{
+		return (
+			$this->getSide(Facing::rotateY($this->facing, false)) instanceof Wall or
+			$this->getSide(Facing::rotateY($this->facing, true)) instanceof Wall
+		);
 	}
 
-	public function getVariantBitmask() : int{
-		return 0;
-	}
-
-	public function onActivate(Item $item, Player $player = null) : bool{
-		$this->meta = (($this->meta ^ 0x04) & ~0x02);
-
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player !== null){
-			$this->meta |= (($player->getDirection() - 1) & 0x02);
+			$this->facing = $player->getHorizontalFacing();
 		}
 
-		$this->getLevel()->setBlock($this, $this, true);
-		$this->level->addSound(new DoorSound($this));
+		$this->inWall = $this->checkInWall();
+
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onNearbyBlockChange() : void{
+		$inWall = $this->checkInWall();
+		if($inWall !== $this->inWall){
+			$this->inWall = $inWall;
+			$this->world->setBlock($this, $this);
+		}
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$this->open = !$this->open;
+		if($this->open and $player !== null){
+			$playerFacing = $player->getHorizontalFacing();
+			if($playerFacing === Facing::opposite($this->facing)){
+				$this->facing = $playerFacing;
+			}
+		}
+
+		$this->getWorld()->setBlock($this, $this);
+		$this->world->addSound($this, new DoorSound());
 		return true;
 	}
 

src/pocketmine/block/Fire.php

@@ -23,6 +23,7 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\entity\Entity;
 use pocketmine\entity\projectile\Arrow;
 use pocketmine\event\block\BlockBurnEvent;
@@ -30,39 +31,44 @@ use pocketmine\event\entity\EntityCombustByBlockEvent;
 use pocketmine\event\entity\EntityDamageByBlockEvent;
 use pocketmine\event\entity\EntityDamageEvent;
 use pocketmine\item\Item;
-use pocketmine\math\Vector3;
+use pocketmine\math\Facing;
 use function min;
 use function mt_rand;
 
 class Fire extends Flowable{
 
-	protected $id = self::FIRE;
+	/** @var int */
+	protected $age = 0;
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? BlockBreakInfo::instant());
+	}
+
+	protected function writeStateToMeta() : int{
+		return $this->age;
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->age = BlockDataSerializer::readBoundedInt("age", $stateMeta, 0, 15);
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111;
 	}
 
 	public function hasEntityCollision() : bool{
 		return true;
 	}
 
-	public function getName() : string{
-		return "Fire Block";
-	}
-
 	public function getLightLevel() : int{
 		return 15;
 	}
 
-	public function isBreakable(Item $item) : bool{
-		return false;
-	}
-
 	public function canBeReplaced() : bool{
 		return true;
 	}
 
-	public function onEntityCollide(Entity $entity) : void{
+	public function onEntityInside(Entity $entity) : void{
 		$ev = new EntityDamageByBlockEvent($this, $entity, EntityDamageEvent::CAUSE_FIRE, 1);
 		$entity->attack($ev);
 
@@ -81,10 +87,10 @@ class Fire extends Flowable{
 	}
 
 	public function onNearbyBlockChange() : void{
-		if(!$this->getSide(Vector3::SIDE_DOWN)->isSolid() and !$this->hasAdjacentFlammableBlocks()){
-			$this->getLevel()->setBlock($this, BlockFactory::get(Block::AIR), true);
+		if(!$this->getSide(Facing::DOWN)->isSolid() and !$this->hasAdjacentFlammableBlocks()){
+			$this->getWorld()->setBlock($this, VanillaBlocks::AIR());
 		}else{
-			$this->level->scheduleDelayedBlockUpdate($this, mt_rand(30, 40));
+			$this->world->scheduleDelayedBlockUpdate($this, mt_rand(30, 40));
 		}
 	}
 
@@ -93,35 +99,35 @@ class Fire extends Flowable{
 	}
 
 	public function onRandomTick() : void{
-		$down = $this->getSide(Vector3::SIDE_DOWN);
+		$down = $this->getSide(Facing::DOWN);
 
 		$result = null;
-		if($this->meta < 15 and mt_rand(0, 2) === 0){
-			$this->meta++;
+		if($this->age < 15 and mt_rand(0, 2) === 0){
+			$this->age++;
 			$result = $this;
 		}
 		$canSpread = true;
 
 		if(!$down->burnsForever()){
 			//TODO: check rain
-			if($this->meta === 15){
+			if($this->age === 15){
 				if(!$down->isFlammable() and mt_rand(0, 3) === 3){ //1/4 chance to extinguish
 					$canSpread = false;
-					$result = BlockFactory::get(Block::AIR);
+					$result = VanillaBlocks::AIR();
 				}
 			}elseif(!$this->hasAdjacentFlammableBlocks()){
 				$canSpread = false;
-				if(!$down->isSolid() or $this->meta > 3){ //fire older than 3, or without a solid block below
-					$result = BlockFactory::get(Block::AIR);
+				if(!$down->isSolid() or $this->age > 3){
+					$result = VanillaBlocks::AIR();
 				}
 			}
 		}
 
 		if($result !== null){
-			$this->level->setBlock($this, $result);
+			$this->world->setBlock($this, $result);
 		}
 
-		$this->level->scheduleDelayedBlockUpdate($this, mt_rand(30, 40));
+		$this->world->scheduleDelayedBlockUpdate($this, mt_rand(30, 40));
 
 		if($canSpread){
 			//TODO: raise upper bound for chance in humid biomes
@@ -131,8 +137,8 @@ class Fire extends Flowable{
 			}
 
 			//vanilla uses a 250 upper bound here, but I don't think they intended to increase the chance of incineration
-			$this->burnBlock($this->getSide(Vector3::SIDE_UP), 350);
-			$this->burnBlock($this->getSide(Vector3::SIDE_DOWN), 350);
+			$this->burnBlock($this->getSide(Facing::UP), 350);
+			$this->burnBlock($this->getSide(Facing::DOWN), 350);
 
 			//TODO: fire spread
 		}
@@ -143,8 +149,8 @@ class Fire extends Flowable{
 	}
 
 	private function hasAdjacentFlammableBlocks() : bool{
-		for($i = 0; $i <= 5; ++$i){
-			if($this->getSide($i)->isFlammable()){
+		foreach(Facing::ALL as $face){
+			if($this->getSide($face)->isFlammable()){
 				return true;
 			}
 		}
@@ -159,10 +165,12 @@ class Fire extends Flowable{
 			if(!$ev->isCancelled()){
 				$block->onIncinerate();
 
-				if(mt_rand(0, $this->meta + 9) < 5){ //TODO: check rain
-					$this->level->setBlock($block, BlockFactory::get(Block::FIRE, min(15, $this->meta + (mt_rand(0, 4) >> 2))));
+				if(mt_rand(0, $this->age + 9) < 5){ //TODO: check rain
+					$fire = clone $this;
+					$fire->age = min(15, $fire->age + (mt_rand(0, 4) >> 2));
+					$this->world->setBlock($block, $fire);
 				}else{
-					$this->level->setBlock($block, BlockFactory::get(Block::AIR));
+					$this->world->setBlock($block, VanillaBlocks::AIR());
 				}
 			}
 		}

src/pocketmine/block/Flowable.php

@@ -31,10 +31,6 @@ abstract class Flowable extends Transparent{
 		return true;
 	}
 
-	public function getHardness() : float{
-		return 0;
-	}
-
 	public function isSolid() : bool{
 		return false;
 	}

src/pocketmine/block/Flower.php

@@ -24,55 +24,29 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
 class Flower extends Flowable{
-	public const TYPE_POPPY = 0;
-	public const TYPE_BLUE_ORCHID = 1;
-	public const TYPE_ALLIUM = 2;
-	public const TYPE_AZURE_BLUET = 3;
-	public const TYPE_RED_TULIP = 4;
-	public const TYPE_ORANGE_TULIP = 5;
-	public const TYPE_WHITE_TULIP = 6;
-	public const TYPE_PINK_TULIP = 7;
-	public const TYPE_OXEYE_DAISY = 8;
 
-	protected $id = self::RED_FLOWER;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? BlockBreakInfo::instant());
 	}
 
-	public function getName() : string{
-		static $names = [
-			self::TYPE_POPPY => "Poppy",
-			self::TYPE_BLUE_ORCHID => "Blue Orchid",
-			self::TYPE_ALLIUM => "Allium",
-			self::TYPE_AZURE_BLUET => "Azure Bluet",
-			self::TYPE_RED_TULIP => "Red Tulip",
-			self::TYPE_ORANGE_TULIP => "Orange Tulip",
-			self::TYPE_WHITE_TULIP => "White Tulip",
-			self::TYPE_PINK_TULIP => "Pink Tulip",
-			self::TYPE_OXEYE_DAISY => "Oxeye Daisy"
-		];
-		return $names[$this->getVariant()] ?? "Unknown";
-	}
-
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$down = $this->getSide(Vector3::SIDE_DOWN);
-		if($down->getId() === Block::GRASS or $down->getId() === Block::DIRT or $down->getId() === Block::FARMLAND){
-			$this->getLevel()->setBlock($blockReplace, $this, true);
-
-			return true;
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$down = $this->getSide(Facing::DOWN);
+		if($down->getId() === BlockLegacyIds::GRASS or $down->getId() === BlockLegacyIds::DIRT or $down->getId() === BlockLegacyIds::FARMLAND){
+			return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 		}
 
 		return false;
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			$this->getLevel()->useBreakOn($this);
+		if($this->getSide(Facing::DOWN)->isTransparent()){
+			$this->getWorld()->useBreakOn($this);
 		}
 	}
 

src/pocketmine/block/FlowerPot.php

@@ -23,90 +23,138 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\tile\FlowerPot as TileFlowerPot;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
-use pocketmine\tile\FlowerPot as TileFlowerPot;
-use pocketmine\tile\Tile;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
+use function assert;
 
 class FlowerPot extends Flowable{
 
-	public const STATE_EMPTY = 0;
-	public const STATE_FULL = 1;
+	/**
+	 * TODO: get rid of this hack (it's currently needed to deal with blockfactory state handling)
+	 * @var bool
+	 */
+	protected $occupied = false;
 
-	protected $id = self::FLOWER_POT_BLOCK;
-	protected $itemId = Item::FLOWER_POT;
+	/** @var Block|null */
+	protected $plant = null;
 
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? BlockBreakInfo::instant());
 	}
 
-	public function getName() : string{
-		return "Flower Pot";
+	protected function writeStateToMeta() : int{
+		return $this->occupied ? BlockLegacyMetadata::FLOWER_POT_FLAG_OCCUPIED : 0;
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->occupied = ($stateMeta & BlockLegacyMetadata::FLOWER_POT_FLAG_OCCUPIED) !== 0;
+	}
+
+	public function getStateBitmask() : int{
+		return 0b1111; //vanilla uses various values, we only care about 1 and 0 for PE
+	}
+
+	public function readStateFromWorld() : void{
+		parent::readStateFromWorld();
+		$tile = $this->world->getTile($this);
+		if($tile instanceof TileFlowerPot){
+			$this->setPlant($tile->getPlant());
+		}else{
+			$this->occupied = false;
+		}
+	}
+
+	public function writeStateToWorld() : void{
+		parent::writeStateToWorld();
+
+		$tile = $this->world->getTile($this);
+		assert($tile instanceof TileFlowerPot);
+		$tile->setPlant($this->plant);
+	}
+
+	/**
+	 * @return Block|null
+	 */
+	public function getPlant() : ?Block{
+		return $this->plant;
+	}
+
+	/**
+	 * @param Block|null $plant
+	 */
+	public function setPlant(?Block $plant) : void{
+		if($plant === null or $plant instanceof Air){
+			$this->plant = null;
+		}else{
+			$this->plant = clone $plant;
+		}
+		$this->occupied = $this->plant !== null;
+	}
+
+	public function canAddPlant(Block $block) : bool{
+		if($this->plant !== null){
+			return false;
+		}
+
+		return
+			$block instanceof Cactus or
+			$block instanceof DeadBush or
+			$block instanceof Flower or
+			$block instanceof RedMushroom or
+			$block instanceof Sapling or
+			($block instanceof TallGrass and $block->getIdInfo()->getVariant() === BlockLegacyMetadata::TALLGRASS_FERN); //TODO: clean up
+		//TODO: bamboo
 	}
 
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-		return new AxisAlignedBB(
-			$this->x + 0.3125,
-			$this->y,
-			$this->z + 0.3125,
-			$this->x + 0.6875,
-			$this->y + 0.375,
-			$this->z + 0.6875
-		);
+		return AxisAlignedBB::one()->contract(3 / 16, 0, 3 / 16)->trim(Facing::UP, 5 / 8);
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($this->getSide(Facing::DOWN)->isTransparent()){
 			return false;
 		}
 
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
-		Tile::createTile(Tile::FLOWER_POT, $this->getLevel(), TileFlowerPot::createNBT($this, $face, $item, $player));
-		return true;
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			$this->getLevel()->useBreakOn($this);
+		if($this->getSide(Facing::DOWN)->isTransparent()){
+			$this->getWorld()->useBreakOn($this);
 		}
 	}
 
-	public function onActivate(Item $item, Player $player = null) : bool{
-		$pot = $this->getLevel()->getTile($this);
-		if(!($pot instanceof TileFlowerPot)){
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		$plant = $item->getBlock();
+		if(!$this->canAddPlant($plant)){
 			return false;
 		}
-		if(!$pot->canAddItem($item)){
-			return true;
-		}
 
-		$this->setDamage(self::STATE_FULL); //specific damage value is unnecessary, it just needs to be non-zero to show an item.
-		$this->getLevel()->setBlock($this, $this, true, false);
-		$pot->setItem($item->pop());
+		$this->setPlant($plant);
+		$item->pop();
+		$this->world->setBlock($this, $this);
 
 		return true;
 	}
 
-	public function getVariantBitmask() : int{
-		return 0;
-	}
-
 	public function getDropsForCompatibleTool(Item $item) : array{
 		$items = parent::getDropsForCompatibleTool($item);
-
-		$tile = $this->getLevel()->getTile($this);
-		if($tile instanceof TileFlowerPot){
-			$item = $tile->getItem();
-			if($item->getId() !== Item::AIR){
-				$items[] = $item;
-			}
+		if($this->plant !== null){
+			$items[] = $this->plant->asItem();
 		}
 
 		return $items;
 	}
 
+	public function getPickedItem(bool $addUserData = false) : Item{
+		return $this->plant !== null ? $this->plant->asItem() : parent::getPickedItem($addUserData);
+	}
+
 	public function isAffectedBySilkTouch() : bool{
 		return false;
 	}

src/pocketmine/block/FrostedIce.php

@@ -0,0 +1,115 @@
+<?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;
+
+use pocketmine\block\utils\BlockDataSerializer;
+use function max;
+use function mt_rand;
+
+class FrostedIce extends Ice{
+
+	/** @var int */
+	protected $age = 0;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(2.5, BlockToolType::PICKAXE));
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->age = BlockDataSerializer::readBoundedInt("age", $stateMeta, 0, 3);
+	}
+
+	protected function writeStateToMeta() : int{
+		return $this->age;
+	}
+
+	public function getStateBitmask() : int{
+		return 0b11;
+	}
+
+	public function onNearbyBlockChange() : void{
+		if(!$this->checkAdjacentBlocks(2)){
+			$this->world->useBreakOn($this);
+		}else{
+			$this->world->scheduleDelayedBlockUpdate($this, mt_rand(20, 40));
+		}
+	}
+
+	public function onRandomTick() : void{
+		if((!$this->checkAdjacentBlocks(4) or mt_rand(0, 2) === 0) and
+			max( //TODO: move this to World
+				$this->world->getHighestAdjacentBlockLight($this->x, $this->y, $this->z),
+				$this->world->getHighestAdjacentBlockSkyLight($this->x, $this->y, $this->z) - $this->world->getSkyLightReduction()
+			) >= 12 - $this->age){
+			if($this->tryMelt()){
+				foreach($this->getAllSides() as $block){
+					if($block instanceof FrostedIce){
+						$block->tryMelt();
+					}
+				}
+			}
+		}else{
+			$this->world->scheduleDelayedBlockUpdate($this, mt_rand(20, 40));
+		}
+	}
+
+	public function onScheduledUpdate() : void{
+		$this->onRandomTick();
+	}
+
+	private function checkAdjacentBlocks(int $requirement) : bool{
+		$found = 0;
+		for($x = -1; $x <= 1; ++$x){
+			for($z = -1; $z <= 1; ++$z){
+				if($x === 0 and $z === 0){
+					continue;
+				}
+				if(
+					$this->world->getBlockAt($this->x + $x, $this->y, $this->z + $z) instanceof FrostedIce and
+					++$found >= $requirement
+				){
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Updates the age of the ice, destroying it if appropriate.
+	 *
+	 * @return bool Whether the ice was destroyed.
+	 */
+	private function tryMelt() : bool{
+		if($this->age >= 3){
+			$this->world->useBreakOn($this);
+			return true;
+		}
+
+		$this->age++;
+		$this->world->setBlock($this, $this);
+		$this->world->scheduleDelayedBlockUpdate($this, mt_rand(20, 40));
+		return false;
+	}
+}

src/pocketmine/block/Furnace.php

@@ -23,16 +23,86 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\tile\Furnace as TileFurnace;
+use pocketmine\block\utils\BlockDataSerializer;
+use pocketmine\item\Item;
+use pocketmine\item\ToolTier;
+use pocketmine\math\Facing;
+use pocketmine\math\Vector3;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
-class Furnace extends BurningFurnace{
+class Furnace extends Opaque{
+	/** @var BlockIdentifierFlattened */
+	protected $idInfo;
 
-	protected $id = self::FURNACE;
+	/** @var int */
+	protected $facing = Facing::NORTH;
+	/** @var bool */
+	protected $lit = false; //this is set based on the blockID
 
-	public function getName() : string{
-		return "Furnace";
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(3.5, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel()));
+	}
+
+	public function getId() : int{
+		return $this->lit ? $this->idInfo->getSecondId() : parent::getId();
+	}
+
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeHorizontalFacing($this->facing);
+	}
+
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readHorizontalFacing($stateMeta);
+		$this->lit = $id === $this->idInfo->getSecondId();
+	}
+
+	public function getStateBitmask() : int{
+		return 0b111;
 	}
 
 	public function getLightLevel() : int{
-		return 0;
+		return $this->lit ? 13 : 0;
+	}
+
+	public function isLit() : bool{
+		return $this->lit;
+	}
+
+	/**
+	 * @param bool $lit
+	 *
+	 * @return $this
+	 */
+	public function setLit(bool $lit = true) : self{
+		$this->lit = $lit;
+		return $this;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player !== null){
+			$this->facing = Facing::opposite($player->getHorizontalFacing());
+		}
+
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
+	}
+
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($player instanceof Player){
+			$furnace = $this->getWorld()->getTile($this);
+			if($furnace instanceof TileFurnace and $furnace->canOpenWith($item->getCustomName())){
+				$player->setCurrentWindow($furnace->getInventory());
+			}
+		}
+
+		return true;
+	}
+
+	public function onScheduledUpdate() : void{
+		$furnace = $this->getWorld()->getTile($this);
+		if($furnace instanceof TileFurnace and $furnace->onUpdate()){
+			$this->world->scheduleDelayedBlockUpdate($this, 1); //TODO: check this
+		}
 	}
 }

src/pocketmine/block/Glass.php

@@ -27,18 +27,8 @@ use pocketmine\item\Item;
 
 class Glass extends Transparent{
 
-	protected $id = self::GLASS;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Glass";
-	}
-
-	public function getHardness() : float{
-		return 0.3;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.3));
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{

src/pocketmine/block/GlassPane.php

@@ -27,18 +27,8 @@ use pocketmine\item\Item;
 
 class GlassPane extends Thin{
 
-	protected $id = self::GLASS_PANE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Glass Pane";
-	}
-
-	public function getHardness() : float{
-		return 0.3;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.3));
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{

src/pocketmine/block/GlazedTerracotta.php

@@ -24,40 +24,40 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\BlockDataSerializer;
 use pocketmine\item\Item;
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
+use pocketmine\world\BlockTransaction;
 
-class GlazedTerracotta extends Solid{
+class GlazedTerracotta extends Opaque{
 
-	public function getHardness() : float{
-		return 1.4;
+	/** @var int */
+	protected $facing = Facing::NORTH;
+
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(1.4, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel()));
 	}
 
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
+	protected function writeStateToMeta() : int{
+		return BlockDataSerializer::writeHorizontalFacing($this->facing);
 	}
 
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
+	public function readStateFromData(int $id, int $stateMeta) : void{
+		$this->facing = BlockDataSerializer::readHorizontalFacing($stateMeta);
 	}
 
-	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
+	public function getStateBitmask() : int{
+		return 0b111;
+	}
+
+	public function place(BlockTransaction $tx, Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
 		if($player !== null){
-			$faces = [
-				0 => 4,
-				1 => 3,
-				2 => 5,
-				3 => 2
-			];
-			$this->meta = $faces[(~($player->getDirection() - 1)) & 0x03];
+			$this->facing = Facing::opposite($player->getHorizontalFacing());
 		}
 
-		return $this->getLevel()->setBlock($blockReplace, $this, true, true);
-	}
-
-	public function getVariantBitmask() : int{
-		return 0;
+		return parent::place($tx, $item, $blockReplace, $blockClicked, $face, $clickVector, $player);
 	}
 }

src/pocketmine/block/GlowingObsidian.php

@@ -24,37 +24,15 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
 
-class GlowingObsidian extends Solid{
+class GlowingObsidian extends Opaque{
 
-	protected $id = self::GLOWING_OBSIDIAN;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Glowing Obsidian";
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(10.0, BlockToolType::PICKAXE, ToolTier::DIAMOND()->getHarvestLevel(), 50.0));
 	}
 
 	public function getLightLevel() : int{
 		return 12;
 	}
-
-	public function getHardness() : float{
-		return 10;
-	}
-
-	public function getBlastResistance() : float{
-		return 50;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_DIAMOND;
-	}
 }

src/pocketmine/block/GlowingRedstoneOre.php

@@ -1,58 +0,0 @@
-<?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;
-
-use pocketmine\item\Item;
-use pocketmine\Player;
-
-class GlowingRedstoneOre extends RedstoneOre{
-
-	protected $id = self::GLOWING_REDSTONE_ORE;
-
-	protected $itemId = self::REDSTONE_ORE;
-
-	public function getName() : string{
-		return "Glowing Redstone Ore";
-	}
-
-	public function getLightLevel() : int{
-		return 9;
-	}
-
-	public function onActivate(Item $item, Player $player = null) : bool{
-		return false;
-	}
-
-	public function onNearbyBlockChange() : void{
-
-	}
-
-	public function ticksRandomly() : bool{
-		return true;
-	}
-
-	public function onRandomTick() : void{
-		$this->getLevel()->setBlock($this, BlockFactory::get(Block::REDSTONE_ORE, $this->meta), false, false);
-	}
-}

src/pocketmine/block/Glowstone.php

@@ -24,27 +24,13 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
 use function mt_rand;
 
 class Glowstone extends Transparent{
 
-	protected $id = self::GLOWSTONE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Glowstone";
-	}
-
-	public function getHardness() : float{
-		return 0.3;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.3, BlockToolType::PICKAXE));
 	}
 
 	public function getLightLevel() : int{
@@ -53,7 +39,7 @@ class Glowstone extends Transparent{
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::GLOWSTONE_DUST, 0, mt_rand(2, 4))
+			VanillaItems::GLOWSTONE_DUST()->setCount(mt_rand(2, 4))
 		];
 	}
 }

src/pocketmine/block/Gold.php

@@ -1,51 +0,0 @@
-<?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;
-
-use pocketmine\item\TieredTool;
-
-class Gold extends Solid{
-
-	protected $id = self::GOLD_BLOCK;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Gold Block";
-	}
-
-	public function getHardness() : float{
-		return 3;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_IRON;
-	}
-}

src/pocketmine/block/GoldOre.php

@@ -1,51 +0,0 @@
-<?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;
-
-use pocketmine\item\TieredTool;
-
-class GoldOre extends Solid{
-
-	protected $id = self::GOLD_ORE;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Gold Ore";
-	}
-
-	public function getHardness() : float{
-		return 3;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_IRON;
-	}
-}

src/pocketmine/block/Grass.php

@@ -24,39 +24,26 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\event\block\BlockSpreadEvent;
+use pocketmine\item\Fertilizer;
 use pocketmine\item\Hoe;
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
 use pocketmine\item\Shovel;
-use pocketmine\level\generator\object\TallGrass as TallGrassObject;
+use pocketmine\math\Facing;
 use pocketmine\math\Vector3;
-use pocketmine\Player;
+use pocketmine\player\Player;
 use pocketmine\utils\Random;
+use pocketmine\world\generator\object\TallGrass as TallGrassObject;
 use function mt_rand;
 
-class Grass extends Solid{
+class Grass extends Opaque{
 
-	protected $id = self::GRASS;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Grass";
-	}
-
-	public function getHardness() : float{
-		return 0.6;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_SHOVEL;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.6, BlockToolType::SHOVEL));
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::DIRT)
+			VanillaBlocks::DIRT()->asItem()
 		];
 	}
 
@@ -65,13 +52,13 @@ class Grass extends Solid{
 	}
 
 	public function onRandomTick() : void{
-		$lightAbove = $this->level->getFullLightAt($this->x, $this->y + 1, $this->z);
-		if($lightAbove < 4 and BlockFactory::$lightFilter[$this->level->getBlockIdAt($this->x, $this->y + 1, $this->z)] >= 3){ //2 plus 1 standard filter amount
+		$lightAbove = $this->world->getFullLightAt($this->x, $this->y + 1, $this->z);
+		if($lightAbove < 4 and $this->world->getBlockAt($this->x, $this->y + 1, $this->z)->getLightFilter() >= 2){
 			//grass dies
-			$ev = new BlockSpreadEvent($this, $this, BlockFactory::get(Block::DIRT));
+			$ev = new BlockSpreadEvent($this, $this, VanillaBlocks::DIRT());
 			$ev->call();
 			if(!$ev->isCancelled()){
-				$this->level->setBlock($this, $ev->getNewState(), false, false);
+				$this->world->setBlock($this, $ev->getNewState(), false);
 			}
 		}elseif($lightAbove >= 9){
 			//try grass spread
@@ -79,38 +66,43 @@ class Grass extends Solid{
 				$x = mt_rand($this->x - 1, $this->x + 1);
 				$y = mt_rand($this->y - 3, $this->y + 1);
 				$z = mt_rand($this->z - 1, $this->z + 1);
+
+				$b = $this->world->getBlockAt($x, $y, $z);
 				if(
-					$this->level->getBlockIdAt($x, $y, $z) !== Block::DIRT or
-					$this->level->getBlockDataAt($x, $y, $z) === 1 or
-					$this->level->getFullLightAt($x, $y + 1, $z) < 4 or
-					BlockFactory::$lightFilter[$this->level->getBlockIdAt($x, $y + 1, $z)] >= 3
+					!($b instanceof Dirt) or
+					$b instanceof CoarseDirt or
+					$this->world->getFullLightAt($x, $y + 1, $z) < 4 or
+					$this->world->getBlockAt($x, $y + 1, $z)->getLightFilter() >= 2
 				){
 					continue;
 				}
 
-				$ev = new BlockSpreadEvent($b = $this->level->getBlockAt($x, $y, $z), $this, BlockFactory::get(Block::GRASS));
+				$ev = new BlockSpreadEvent($b, $this, VanillaBlocks::GRASS());
 				$ev->call();
 				if(!$ev->isCancelled()){
-					$this->level->setBlock($b, $ev->getNewState(), false, false);
+					$this->world->setBlock($b, $ev->getNewState(), false);
 				}
 			}
 		}
 	}
 
-	public function onActivate(Item $item, Player $player = null) : bool{
-		if($item->getId() === Item::DYE and $item->getDamage() === 0x0F){
-			$item->count--;
-			TallGrassObject::growGrass($this->getLevel(), $this, new Random(mt_rand()), 8, 2);
+	public function onInteract(Item $item, int $face, Vector3 $clickVector, ?Player $player = null) : bool{
+		if($face !== Facing::UP){
+			return false;
+		}
+		if($item instanceof Fertilizer){
+			$item->pop();
+			TallGrassObject::growGrass($this->getWorld(), $this, new Random(mt_rand()), 8, 2);
 
 			return true;
 		}elseif($item instanceof Hoe){
 			$item->applyDamage(1);
-			$this->getLevel()->setBlock($this, BlockFactory::get(Block::FARMLAND));
+			$this->getWorld()->setBlock($this, VanillaBlocks::FARMLAND());
 
 			return true;
-		}elseif($item instanceof Shovel and $this->getSide(Vector3::SIDE_UP)->getId() === Block::AIR){
+		}elseif($item instanceof Shovel and $this->getSide(Facing::UP)->getId() === BlockLegacyIds::AIR){
 			$item->applyDamage(1);
-			$this->getLevel()->setBlock($this, BlockFactory::get(Block::GRASS_PATH));
+			$this->getWorld()->setBlock($this, VanillaBlocks::GRASS_PATH());
 
 			return true;
 		}

src/pocketmine/block/GrassPath.php

@@ -24,50 +24,28 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
 use pocketmine\math\AxisAlignedBB;
-use pocketmine\math\Vector3;
+use pocketmine\math\Facing;
 
 class GrassPath extends Transparent{
 
-	protected $id = self::GRASS_PATH;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Grass Path";
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_SHOVEL;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.6, BlockToolType::SHOVEL));
 	}
 
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
-		return new AxisAlignedBB(
-			$this->x,
-			$this->y,
-			$this->z,
-			$this->x + 1,
-			$this->y + 1, //TODO: this should be 0.9375, but MCPE currently treats them as a full block (https://bugs.mojang.com/browse/MCPE-12109)
-			$this->z + 1
-		);
-	}
-
-	public function getHardness() : float{
-		return 0.6;
+		return AxisAlignedBB::one(); //TODO: this should be trimmed at the top by 1/16, but MCPE currently treats them as a full block (https://bugs.mojang.com/browse/MCPE-12109)
 	}
 
 	public function onNearbyBlockChange() : void{
-		if($this->getSide(Vector3::SIDE_UP)->isSolid()){
-			$this->level->setBlock($this, BlockFactory::get(Block::DIRT), true);
+		if($this->getSide(Facing::UP)->isSolid()){
+			$this->world->setBlock($this, VanillaBlocks::DIRT());
 		}
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		return [
-			ItemFactory::get(Item::DIRT)
+			VanillaBlocks::DIRT()->asItem()
 		];
 	}
 }

src/pocketmine/block/Gravel.php

@@ -23,37 +23,30 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\block\utils\Fallable;
+use pocketmine\block\utils\FallableTrait;
 use pocketmine\item\Item;
-use pocketmine\item\ItemFactory;
+use pocketmine\item\VanillaItems;
 use function mt_rand;
 
-class Gravel extends Fallable{
+class Gravel extends Opaque implements Fallable{
+	use FallableTrait;
 
-	protected $id = self::GRAVEL;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Gravel";
-	}
-
-	public function getHardness() : float{
-		return 0.6;
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_SHOVEL;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(0.6, BlockToolType::SHOVEL));
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
 		if(mt_rand(1, 10) === 1){
 			return [
-				ItemFactory::get(Item::FLINT)
+				VanillaItems::FLINT()
 			];
 		}
 
 		return parent::getDropsForCompatibleTool($item);
 	}
+
+	public function tickFalling() : ?Block{
+		return null;
+	}
 }

src/pocketmine/block/HardenedClay.php

@@ -23,29 +23,11 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-use pocketmine\item\TieredTool;
+use pocketmine\item\ToolTier;
 
-class HardenedClay extends Solid{
+class HardenedClay extends Opaque{
 
-	protected $id = self::HARDENED_CLAY;
-
-	public function __construct(int $meta = 0){
-		$this->meta = $meta;
-	}
-
-	public function getName() : string{
-		return "Hardened Clay";
-	}
-
-	public function getToolType() : int{
-		return BlockToolType::TYPE_PICKAXE;
-	}
-
-	public function getToolHarvestLevel() : int{
-		return TieredTool::TIER_WOODEN;
-	}
-
-	public function getHardness() : float{
-		return 1.25;
+	public function __construct(BlockIdentifier $idInfo, string $name, ?BlockBreakInfo $breakInfo = null){
+		parent::__construct($idInfo, $name, $breakInfo ?? new BlockBreakInfo(1.25, BlockToolType::PICKAXE, ToolTier::WOOD()->getHarvestLevel(), 21.0));
 	}
 }