Release 3.17.1

this gives a more granular view of test failures and also allows independent steps to run in parallel.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Help & support on Discord
+    url: https://discord.gg/bmSAZBG
+    about: We don't accept support requests on the issue tracker. Please try asking on Discord instead.
+  - name: Help & support on forums
+    url: https://forums.pmmp.io
+    about: We don't accept support requests on the issue tracker. Please try asking on forums instead.
+  - name: Documentation
+    url: https://pmmp.rtfd.io
+    about: PocketMine-MP documentation

.github/ISSUE_TEMPLATE/crash.md

@@ -9,6 +9,7 @@ assignees: ''
 
 <!--- submit crashdump files to https://crash.pmmp.io -->
 <!--- or, copy the data between ===BEGIN CRASH DUMP=== and ===END CRASH DUMP and paste it on a site like https://pastebin.com -->
+<!--- DON'T JUST PASTE the crashdump into an issue -->
 Link to crashdump: 
 
 <!--- write additional information about the crash to help us find the problem -->

.github/ISSUE_TEMPLATE/help---support.md

@@ -1,14 +0,0 @@
----
-name: Help & support
-about: We don't accept support requests here. Try the links on the README.
-title: ''
-labels: Support request
-assignees: ''
-
----
-
-We don't accept support requests on the issue tracker. Please try the following links instead:
-
-Documentation: http://pmmp.rtfd.io
-Forums: https://forums.pmmp.io
-Discord: https://discord.gg/bmSAZBG

.github/ISSUE_TEMPLATE/security-dos-vulnerability.md

@@ -1,12 +0,0 @@
----
-name: Security/DoS vulnerability
-about: 'Bug or exploit that can be used to attack servers (hint: don''t report it
-  on a public issue tracker)'
-title: ''
-labels: 'Auto: Spam'
-assignees: ''
-
----
-
-Please DO NOT report security vulnerabilities here.
-Instead, send an email to team@pmmp.io or contact a developer directly, IN PRIVATE.

.github/workflows/main.yml

@@ -0,0 +1,147 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build-php:
+    name: Prepare PHP
+    runs-on: ubuntu-latest
+    
+    steps:
+      - uses: actions/checkout@v2 #needed for build.sh
+      - name: Check for PHP build cache
+        id: php-build-cache
+        uses: actions/cache@v2
+        with:
+          path: "./bin"
+          key: "php-build-generic-${{ hashFiles('./tests/gh-actions/build.sh') }}"
+
+      - name: Compile PHP
+        if: steps.php-build-cache.outputs.cache-hit != 'true'
+        run: ./tests/gh-actions/build.sh
+
+  phpstan:
+    name: PHPStan analysis
+    needs: build-php
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Restore PHP build cache
+        id: php-build-cache
+        uses: actions/cache@v2
+        with:
+          path: "./bin"
+          key: "php-build-generic-${{ hashFiles('./tests/gh-actions/build.sh') }}"
+
+      - name: Kill build on PHP build cache miss (should never happen)
+        if: steps.php-build-cache.outputs.cache-hit != 'true'
+        run: exit 1
+
+      - name: Prefix PHP to PATH
+        run: echo "$(pwd)/bin/php7/bin" >> $GITHUB_PATH
+
+      - name: Install Composer
+        run: curl -sS https://getcomposer.org/installer | php
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: php composer.phar install --prefer-dist --no-interaction
+
+      - name: Run PHPStan
+        run: ./vendor/bin/phpstan analyze --no-progress --memory-limit=2G
+
+  phpunit:
+    name: PHPUnit tests
+    needs: build-php
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Restore PHP build cache
+        id: php-build-cache
+        uses: actions/cache@v2
+        with:
+          path: "./bin"
+          key: "php-build-generic-${{ hashFiles('./tests/gh-actions/build.sh') }}"
+
+      - name: Kill build on PHP build cache miss (should never happen)
+        if: steps.php-build-cache.outputs.cache-hit != 'true'
+        run: exit 1
+
+      - name: Prefix PHP to PATH
+        run: echo "$(pwd)/bin/php7/bin" >> $GITHUB_PATH
+
+      - name: Install Composer
+        run: curl -sS https://getcomposer.org/installer | php
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: php composer.phar install --prefer-dist --no-interaction
+
+      - name: Run PHPUnit tests
+        run: ./vendor/bin/phpunit --bootstrap vendor/autoload.php --fail-on-warning tests/phpunit
+
+  integration:
+    name: Integration tests
+    needs: build-php
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+
+      - name: Restore PHP build cache
+        id: php-build-cache
+        uses: actions/cache@v2
+        with:
+          path: "./bin"
+          key: "php-build-generic-${{ hashFiles('./tests/gh-actions/build.sh') }}"
+
+      - name: Kill build on PHP build cache miss (should never happen)
+        if: steps.php-build-cache.outputs.cache-hit != 'true'
+        run: exit 1
+
+      - name: Prefix PHP to PATH
+        run: echo "$(pwd)/bin/php7/bin" >> $GITHUB_PATH
+
+      - name: Install Composer
+        run: curl -sS https://getcomposer.org/installer | php
+
+      - name: Restore Composer package cache
+        uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cache/composer/files
+            ~/.cache/composer/vcs
+          key: "composer-v2-cache-${{ hashFiles('./composer.lock') }}"
+          restore-keys: |
+            composer-v2-cache-
+
+      - name: Install Composer dependencies
+        run: php composer.phar install --no-dev --prefer-dist --no-interaction
+
+      - name: Run integration tests
+        run: ./tests/travis.sh -t4

.gitignore

@@ -41,3 +41,9 @@ test_data/*
 
 # Doxygen
 Documentation/*
+
+# PHPUnit
+/.phpunit.result.cache
+
+# php-cs-fixer
+/.php_cs.cache

.gitmodules

@@ -1,15 +1,15 @@
 [submodule "src/pocketmine/lang/locale"]
 	path = src/pocketmine/lang/locale
-	url = https://github.com/pmmp/PocketMine-Language.git
+	url = https://github.com/pmmp/Language.git
 [submodule "tests/preprocessor"]
 	path = build/preprocessor
 	url = https://github.com/pmmp/preprocessor.git
-[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
-	url = https://github.com/pmmp/BedrockData.git
+[submodule "tests/plugins/DevTools"]
+	path = tests/plugins/DevTools
+	url = https://github.com/pmmp/DevTools.git
 [submodule "build/php"]
 	path = build/php
 	url = https://github.com/pmmp/php-build-scripts.git
+[submodule "src/pocketmine/resources/vanilla"]
+	path = src/pocketmine/resources/vanilla
+	url = https://github.com/pmmp/BedrockData.git

.travis.yml

@@ -1,25 +0,0 @@
-language: php
-
-php:
- - 7.2
- - 7.3
-
-before_script:
-# - pecl install channel://pecl.php.net/pthreads-3.1.6
- - echo | pecl install channel://pecl.php.net/yaml-2.0.4
- - git clone https://github.com/pmmp/pthreads.git
- - cd pthreads
- - git checkout 1b7da492b944146fa9680f6399bd9c6c6c6095e0
- - phpize
- - ./configure
- - make
- - make install
- - cd ..
- - echo "extension=pthreads.so" >> ~/.phpenv/versions/$(phpenv version-name)/etc/php.ini
- - composer install
-
-script:
- - ./tests/travis.sh -t4
-
-notifications:
- email: false

BUILDING.md

@@ -0,0 +1,38 @@
+# Building
+## Pre-requisites
+- A bash shell (git bash is sufficient for Windows)
+- [`git`](https://git-scm.com) available in your shell
+- PHP 7.3 or newer available in your shell
+- [`composer`](https://getcomposer.org) available in your shell
+
+## Custom PHP binaries
+Because PocketMine-MP requires several non-standard PHP extensions and configuration, PMMP provides scripts to build custom binaries for running PocketMine-MP, as well as prebuilt binaries.
+
+- [Prebuilt binaries](https://jenkins.pmmp.io/job/PHP-7.3-Aggregate)
+- [Compile scripts](https://github.com/pmmp/php-build-scripts) are provided as a submodule in the path `build/php`
+
+If you use a custom binary, you'll need to replace `composer` usages in this guide with `path/to/your/php path/to/your/composer.phar`.
+
+## Setting up environment
+1. `git clone --recursive https://github.com/pmmp/PocketMine-MP.git`
+2. `composer install`
+
+## Checking out a different branch to build
+1. `git checkout <branch to checkout>`
+2. `git submodule update --init`
+3. Re-run `composer install` to synchronize dependencies.
+
+## Optimizing for release builds
+1. Add the flags `--no-dev --classmap-authoritative` to your `composer install` command. This will reduce build size and improve autoloading speed.
+2. Preprocess the source code by running `build/preprocessor/PreProcessor.php`. Usage instructions are provided in `build/preprocessor/README.md`.
+
+### Note
+Preprocessor requires that the `cpp` (c preprocessor) is available in your PATH.
+
+## Building `PocketMine-MP.phar`
+Run `composer make-server` using your preferred PHP binary. It'll drop a `PocketMine-MP.phar` into the current working directory.
+
+You can also use the `--out` option to change the output filename.
+
+## Running PocketMine-MP from source code
+Run `src/pocketmine/PocketMine.php` using your preferred PHP binary.

CONTRIBUTING.md

@@ -116,7 +116,7 @@ class ExampleClass{
 <!-- TODO: RFC and voting on the forums instead -->
 ### RFC and Voting
 * These are big Pull Requests or contributions that change important behavior.
-* RFCs will be tagged with the *PR: RFC* label
+* RFCs will be tagged with the *Type: Request For Comments* label
 * A vote will be held once the RFC is ready. All users can vote commenting on the Pull Request
 * Comments MUST use "Yes" or "No" on the FIRST sentence to signify the vote, except when they don't want it to be counted.
 * If your comment is a voting comment, specify the reason of your vote or it won't be counted.

README.md

@@ -3,7 +3,7 @@
 	<b>A highly customisable, open source server software for Minecraft: Bedrock Edition written in PHP</b>
 </p>
 
-[![Build Status](https://travis-ci.org/pmmp/PocketMine-MP.svg?branch=master)](https://travis-ci.org/pmmp/PocketMine-MP)
+![CI](https://github.com/pmmp/PocketMine-MP/workflows/CI/badge.svg)
 
 ## Getting started
 - [Documentation](http://pmmp.readthedocs.org/)
@@ -13,12 +13,13 @@
 
 ## Discussion/Help
 - [Forums](https://forums.pmmp.io/)
-- [Community Discord](https://discord.gg/bmSAZBG)
+- [Discord](https://discord.gg/bmSAZBG)
 - [StackOverflow](https://stackoverflow.com/tags/pocketmine)
 
 ## For developers
+ * [Building and running from source](BUILDING.md)
  * [Latest API documentation](https://jenkins.pmmp.io/job/PocketMine-MP-doc/doxygen/) - Doxygen documentation generated from development
- * [DevTools](https://github.com/pmmp/PocketMine-DevTools/) - Development tools plugin for creating plugins
+ * [DevTools](https://github.com/pmmp/DevTools/) - Development tools plugin for creating plugins
  * [ExamplePlugin](https://github.com/pmmp/ExamplePlugin/) - Example plugin demonstrating some basic API features
  * [Contributing Guidelines](CONTRIBUTING.md)
 

SECURITY.md

@@ -0,0 +1,33 @@
+# Security Policy
+
+## Supported Versions
+The following release lines are currently receiving active security updates and bug fixes:
+
+| Version  | Supported          |
+| -------- | ------------------ |
+| 3.15.x   | :white_check_mark: |
+| < 3.15.0 | :x:                |
+
+## Reporting a Vulnerability
+
+**DO NOT report vulnerabilities on the GitHub issue tracker.**
+GitHub is public and anyone can see the issues you post on the issue tracker, including people who would exploit vulnerabilities for their own gain.
+
+**WARNING: You may put live servers at risk by reporting a vulnerability on the GitHub issue tracker.**
+
+**Contact us** by sending an email to [**team@pmmp.io**](mailto:team@pmmp.io?subject=Security%20Vulnerability%20in%20PocketMine-MP). Include the following information:
+
+- Version of PocketMine-MP
+- Detailed description of the vulnerability (e.g. how to exploit it, what the effects are)
+
+Please note that we can't guarantee a reply to every email.
+
+## FAQ
+### Do you offer a bug bounty?
+No.
+
+### How soon can I expect a fix for a vulnerability I've reported?
+This depends on the nature of the problem. We can't provide any general ETA (nor would it be wise to provide one).
+In general, it depends on when developers have time to look into the problem, how complex the problem is to fix, and how many users it impacts.
+
+When a fix for a severe vulnerability is pushed, a patch release for the target version will usually be released within 24 hours so that users can update.

build/make-release.php

@@ -21,14 +21,14 @@
 
 declare(strict_types=1);
 
-namespace pocketmine\build_script;
+namespace pocketmine\build\make_release;
 
 use pocketmine\utils\VersionString;
+use function defined;
 use function dirname;
 use function fgets;
 use function file_get_contents;
 use function file_put_contents;
-use function preg_quote;
 use function preg_replace;
 use function sleep;
 use function sprintf;
@@ -38,18 +38,6 @@ use const STDIN;
 
 require_once dirname(__DIR__) . '/vendor/autoload.php';
 
-if(isset($argv[1])){
-	$currentVer = new VersionString($argv[1]);
-}else{
-	$currentVer = new VersionString(BASE_VERSION);
-}
-$nextVer = new VersionString(sprintf(
-	"%u.%u.%u",
-	$currentVer->getMajor(),
-	$currentVer->getMinor(),
-	$currentVer->getPatch() + 1
-));
-
 function replaceVersion(string $versionInfoPath, string $newVersion, bool $isDev) : void{
 	$versionInfo = file_get_contents($versionInfoPath);
 	$versionInfo = preg_replace(
@@ -59,22 +47,45 @@ function replaceVersion(string $versionInfoPath, string $newVersion, bool $isDev
 	);
 	$versionInfo = preg_replace(
 		'/^const IS_DEVELOPMENT_BUILD = (?:true|false);$/m',
-		'const IS_DEVELOPMENT_BUILD = ' . ($isDev ? 'true' : 'false'). ';',
+		'const IS_DEVELOPMENT_BUILD = ' . ($isDev ? 'true' : 'false') . ';',
 		$versionInfo
 	);
 	file_put_contents($versionInfoPath, $versionInfo);
 }
-$versionInfoPath = dirname(__DIR__) . '/src/pocketmine/VersionInfo.php';
-replaceVersion($versionInfoPath, $currentVer->getBaseVersion(), false);
 
-echo "please add appropriate notes to the changelog and press enter...";
-fgets(STDIN);
-system('git add "' . dirname(__DIR__) . '/changelogs"');
-system('git commit -m "Release ' . $currentVer->getBaseVersion() . '" --include "' . $versionInfoPath . '"');
-system('git tag ' . $currentVer->getBaseVersion());
-replaceVersion($versionInfoPath, $nextVer->getBaseVersion(), true);
-system('git add "' . $versionInfoPath . '"');
-system('git commit -m "' . $nextVer->getBaseVersion() . ' is next" --include "' . $versionInfoPath . '"');
-echo "pushing changes in 5 seconds\n";
-sleep(5);
-system('git push origin HEAD ' . $currentVer->getBaseVersion());
+/**
+ * @param string[] $argv
+ * @phpstan-param list<string> $argv
+ */
+function main(array $argv) : void{
+	if(isset($argv[1])){
+		$currentVer = new VersionString($argv[1]);
+	}else{
+		$currentVer = new VersionString(BASE_VERSION);
+	}
+	$nextVer = new VersionString(sprintf(
+		"%u.%u.%u",
+		$currentVer->getMajor(),
+		$currentVer->getMinor(),
+		$currentVer->getPatch() + 1
+	));
+
+	$versionInfoPath = dirname(__DIR__) . '/src/pocketmine/VersionInfo.php';
+	replaceVersion($versionInfoPath, $currentVer->getBaseVersion(), false);
+	
+	echo "please add appropriate notes to the changelog and press enter...";
+	fgets(STDIN);
+	system('git add "' . dirname(__DIR__) . '/changelogs"');
+	system('git commit -m "Release ' . $currentVer->getBaseVersion() . '" --include "' . $versionInfoPath . '"');
+	system('git tag ' . $currentVer->getBaseVersion());
+	replaceVersion($versionInfoPath, $nextVer->getBaseVersion(), true);
+	system('git add "' . $versionInfoPath . '"');
+	system('git commit -m "' . $nextVer->getBaseVersion() . ' is next" --include "' . $versionInfoPath . '"');
+	echo "pushing changes in 5 seconds\n";
+	sleep(5);
+	system('git push origin HEAD ' . $currentVer->getBaseVersion());
+}
+
+if(!defined('pocketmine\_PHPSTAN_ANALYSIS')){
+	main($argv);
+}

build/server-phar.php

@@ -24,33 +24,46 @@ declare(strict_types=1);
 namespace pocketmine\build\server_phar;
 
 use pocketmine\utils\Git;
+use function array_map;
+use function count;
+use function defined;
+use function dirname;
+use function file_exists;
+use function getcwd;
+use function getopt;
+use function implode;
+use function ini_get;
+use function microtime;
+use function preg_quote;
+use function realpath;
+use function round;
+use function rtrim;
+use function sprintf;
+use function str_replace;
+use function unlink;
+use const PHP_EOL;
 
 require dirname(__DIR__) . '/vendor/autoload.php';
 
 /**
  * @param string[]    $strings
- * @param string|null $delim
  *
  * @return string[]
  */
-function preg_quote_array(array $strings, string $delim = null) : array{
+function preg_quote_array(array $strings, string $delim) : array{
 	return array_map(function(string $str) use ($delim) : string{ return preg_quote($str, $delim); }, $strings);
 }
 
 /**
- * @param string   $pharPath
- * @param string   $basePath
  * @param string[] $includedPaths
- * @param array    $metadata
- * @param string   $stub
- * @param int      $signatureAlgo
- * @param int|null $compression
+ * @param mixed[]  $metadata
+ * @phpstan-param array<string, mixed> $metadata
  *
  * @return \Generator|string[]
  */
 function buildPhar(string $pharPath, string $basePath, array $includedPaths, array $metadata, string $stub, int $signatureAlgo = \Phar::SHA1, ?int $compression = null){
 	$basePath = rtrim(str_replace("/", DIRECTORY_SEPARATOR, $basePath), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
-	$includedPaths = array_map(function($path){
+	$includedPaths = array_map(function(string $path) : string{
 		return rtrim(str_replace("/", DIRECTORY_SEPARATOR, $path), DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
 	}, $includedPaths);
 	yield "Creating output file $pharPath";
@@ -103,14 +116,9 @@ function buildPhar(string $pharPath, string $basePath, array $includedPaths, arr
 	yield "Added $count files";
 
 	if($compression !== null){
-		yield "Checking for compressible files...";
-		foreach($phar as $file => $finfo){
-			/** @var \PharFileInfo $finfo */
-			if($finfo->getSize() > (1024 * 512)){
-				yield "Compressing " . $finfo->getFilename();
-				$finfo->compress($compression);
-			}
-		}
+		yield "Compressing files...";
+		$phar->compressFiles($compression);
+		yield "Finished compression";
 	}
 	$phar->stopBuffering();
 
@@ -122,10 +130,18 @@ function main() : void{
 		echo "Set phar.readonly to 0 with -dphar.readonly=0" . PHP_EOL;
 		exit(1);
 	}
+	if(file_exists(dirname(__DIR__) . '/vendor/phpunit')){
+		echo "Remove Composer dev dependencies before building (composer install --no-dev)" . PHP_EOL;
+		exit(1);
+	}
 
-	$opts = getopt("", ["out:"]);
-	$gitHash = Git::getRepositoryStatePretty(dirname(__DIR__));
-	echo "Git hash detected as $gitHash" . PHP_EOL;
+	$opts = getopt("", ["out:", "git:"]);
+	if(isset($opts["git"])){
+		$gitHash = $opts["git"];
+	}else{
+		$gitHash = Git::getRepositoryStatePretty(dirname(__DIR__));
+		echo "Git hash detected as $gitHash" . PHP_EOL;
+	}
 	foreach(buildPhar(
 		$opts["out"] ?? getcwd() . DIRECTORY_SEPARATOR . "PocketMine-MP.phar",
 		dirname(__DIR__) . DIRECTORY_SEPARATOR,
@@ -136,7 +152,23 @@ function main() : void{
 		[
 			'git' => $gitHash
 		],
-		'<?php require("phar://" . __FILE__ . "/src/pocketmine/PocketMine.php"); __HALT_COMPILER();'
+		<<<'STUB'
+<?php
+
+$tmpDir = sys_get_temp_dir();
+if(!is_readable($tmpDir) or !is_writable($tmpDir)){
+	echo "ERROR: tmpdir $tmpDir is not accessible." . PHP_EOL;
+	echo "Check that the directory exists, and that the current user has read/write permissions for it." . PHP_EOL;
+	echo "Alternatively, set 'sys_temp_dir' to a different directory in your php.ini file." . PHP_EOL;
+	exit(1);
+}
+
+require("phar://" . __FILE__ . "/src/pocketmine/PocketMine.php");
+__HALT_COMPILER();
+STUB
+,
+		\Phar::SHA1,
+		\Phar::GZ
 	) as $line){
 		echo $line . PHP_EOL;
 	}

changelogs/3.11.md

@@ -53,3 +53,45 @@ Plugin developers should **only** update their required API to this version if y
 - Populate type information in lots of places where it was previously missing; this will improve the quality of static analysis for plugins.
 - `MainLogger::logException()` now logs previous exceptions recursively.
 - `MainLogger::logException()` now always logs exceptions as `critical`.
+
+# 3.11.5
+- PHPStan and PHPUnit are now managed as Composer dev dependencies.
+- Core code is now analyzed using PHPStan level 6 (full, including iterable types checking).
+- Improved type information available to PHPStan in many areas.
+- Mass-removal of useless PHPDoc.
+- Fixed incorrect documentation of `Internet::getURL()`, `Internet::postURL()` and `Internet::simpleCurl()`.
+- Fixed crash on use of case-mismatched recursive command aliases.
+- Basic build instructions are now provided in `BUILDING.md`.
+- `build/server-phar.php` now uses GZIP compression on created phars, providing a 75% size reduction.
+- `ClientboundMapItemDataPacket` now uses `MapDecoration` objects for decorations instead of associative arrays.
+- Updated Composer dependencies to get bug fixes in `pocketmine/nbt` and other libraries.
+- Packages `pocketmine/classloader` and `pocketmine/log` are now required; these provide classes previously part of `pocketmine/spl`. This change has no effect on API compatibility.
+
+# 3.11.6
+- Core code, tests and build scripts are now analyzed using `phpstan-strict-rules` and `phpstan-phpunit` rules.
+- Added more PHPStan-specific type annotations to improve static analysis.
+- Fixed more incorrect PHPDoc types.
+- Added a workaround for player movement not working since 1.14.30.
+- Fixed lava and water buckets being edible since 1.13.
+- `AutoUpdater` is now created before any plugins are loaded.
+- Fixed trees not generating below y=2 in custom generators.
+- Fixed crash when opening a chest improperly unpaired from its pair (destroyed, setBlock(), unloaded, etc.).
+- `ThreadManager` is now lazily initialized.
+- Removed raw NBT storage from `Item` internals. The following methods are now deprecated:
+  - `Item::setCompoundTag()`
+
+# 3.11.7
+- Build system: Fixed crash reports of Jenkins builds being rejected by the crash archive as invalid.
+- Introduced a new dependency on `pocketmine/log-pthreads`, which contains classes separated from `pocketmine/log`.
+- Fixed minimum composer stability preventing any newer version of `pocketmine/pocketmine-mp` being installed than 3.3.4 by replacing `daverandom/callback-validator` with [`pocketmine/callback-validator`](https://github.com/pmmp/CallbackValidator).
+- Fixed every player seeing eating particles when any player eats.
+- Fixed setting held item not working during `BlockBreakEvent`, `PlayerInteractEvent` and `EntityDamageEvent`.
+- Fixed some incorrect documented types in `PlayerQuitEvent` reported by PHPStan.
+- Fixed documentation of `Item->pop()` return value.
+- Fixed server crash on encountering corrupted compressed data stored in region files.
+- Protocol: Split screen header is now properly accounted for during decoding. Note that split screen is still not supported natively, but their packets can be decoded properly now.
+- Protocol: Fixed wrong order of fields in `UpdateTradePacket`.
+- Protocol: Fixed loss of `fullSkinId` when decoding network skins.
+- Fixed RCON not being able to bind to port after a fast server restart.
+
+

changelogs/3.12.md

@@ -0,0 +1,58 @@
+**For Minecraft: Bedrock Edition 1.14.60**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.12.0
+- Added support for Minecraft: Bedrock Edition 1.14.60
+- Removed compatibility with 1.14.0-1.14.30
+
+# 3.12.1
+- Fixed parsing of single-line doc comments for event handlers, e.g. `/** @ignoreCancelled */` should now work correctly.
+- The server will no longer crash on failure to load `level.dat` contents, but will gracefully shutdown instead without producing a crashdump.
+- Fixed some bugs in login verification that could cause undefined behaviour.
+- Fixed item-use behaviour when sneaking - sneaking and clicking a block with an empty hand, and sneaking and using an item, both now follow vanilla behaviour.
+- `start.sh` will now work on platforms where `/bin/bash` is not available, as long as `/usr/bin/env` knows where bash is.
+
+# 3.12.2
+- Fixed permission default timings not being reported in timings reports (they were never stopped, only started).
+- Resource packs with a directory tree like `pack.zip/MyPack/manifest.json` are now supported. Note that the manifest closest to the root will be used.
+- Fixed `SkinImage` height and width being inverted at the protocol layer.
+- Fixed blocks being able to be placed inside the spawn protection radius by clicking the side of a block outside the radius.
+- Fixed server crash when `network.compression-level` is overridden by a CLI parameter.
+- Fixed moving entities spawning themselves to players registered on chunks when the players haven't received the chunk yet.
+- Cocoa pods now drop cocoa beans when broken instead of the block itself.
+
+# 3.12.3
+- Core code is now analyzed using PHPStan level 8 (using baselines). While not all the code is level 8 compliant, this does mean that new code will be held to a higher standard, ensuring quality going forwards.
+- Players no longer burn when melee-attacked by other players. (vanilla parity)
+- Arrows shot by burning players are no longer on fire. (vanilla parity)
+- Fixed a crash that could occur with plugins on Unix filesystems that had backslashes in their names.
+- Cleaned up a whole bunch of unknowns in the protocol layer. Many new constants have been added.
+- Fixed player walking sounds.
+- Default generation queue size has been raised to 32 (previously 8). The previous default was selected in a time when PHP was much less performant than it is today, and in today's world it just needlessly slows things down.
+- Double plants are now burned away by fire.
+- Snow layers can now be stacked. (vanilla parity)
+- Resource pack sending chunk size has been reduced to 128 KB (previously 1 MB). This change was made after analyzing the effects that larger pack chunk sizes have on RakNet. Given the technical evidence, a smaller size, while slightly less bandwidth-efficient, should be more manageable for RakNet due to lower split reassembly overhead and reduced memory pressure.
+- Fixed "switching" (an exploit often complained about by PvP players). Now, the previous damage is subtracted from current damage when an entity is attacked while on cooldown. This means that attacking with a wooden sword and then diamond sword while attack cooldown is active will only deal as much damage as the diamond sword would have, instead of the combined total. This can be controlled using the `EntityDamageEvent::MODIFIER_PREVIOUS_DAMAGE_COOLDOWN` modifier. (vanilla parity)
+- Fixed projectiles knocking mobs back in unexpected directions on collision.
+- Fixed inventories not being synchronized on failed inventory transactions.
+- Vector3s decoded from packets are no longer rounded directly. Instead, the player movement handler takes responsibility for rounding the coordinates to prevent anti cheat doing something it's not supposed to.
+- `mobflame` particle can now be spawned using the `/particle` command.
+- Fixed several internal errors that could occur while modifying writable books.
+- Fixed swapping writable book pages not working in some cases.
+- `WritableBook->getPageText()` no longer throws an exception when the page doesn't exist, but returns null (as it was originally intended to).
+
+# 3.12.4
+- Fixed absorption hearts not being consumed.
+
+# 3.12.5
+- Fixed broken attack cooldowns.
+
+# 3.12.6
+- Fixed entities not getting movement updates after teleports.
+- Fixed slow flight in spectator mode when starting from the ground and after teleportation.
+- Errors communicating with the crash archive on automatic crash submission are now logged.

changelogs/3.13.md

@@ -0,0 +1,131 @@
+**For Minecraft: Bedrock Edition 1.14.60**
+
+This is a feature release, containing various minor API additions, deprecations and a few minor features.
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.13.0
+## Core
+- PHP 7.3.0 or newer is now required.
+- Player movement processing has been revamped. It's now more tolerant of network lag and doesn't have as many problems with falling.
+
+## User Interface
+- `/time` now supports additional aliases `noon`, `sunset`, `midnight` and `sunrise`.
+- Removed warnings when a plugin registers a handler for a deprecated event. Since this warning is developer-focused, and too specific to be useful, it just caused annoyance and confusion to users who didn't know what it meant.
+
+## API
+### General
+- It's now possible to require a specific operating system using the `os` directive in `plugin.yml`. More information about this directive can be found in the [developer documentation](https://github.com/pmmp/DeveloperDocs).
+
+### Player
+- `Player->resetItemCooldown()` now accepts a second parameter, allowing plugins to provide a custom duration.
+- The following methods have been deprecated and have recommended replacements:
+  - `Player->addTitle()` -> `Player->sendTitle()`
+  - `Player->addSubTitle()` -> `Player->sendSubTitle()`
+  - `Player->addActionBarMessage()` -> `Player->sendActionBarMessage()`
+
+### Event
+- The following methods have been deprecated:
+  - `EntityDespawnEvent->getType()`
+  - `EntityDespawnEvent->getPosition()`
+  - `EntityDespawnEvent->isCreature()`
+  - `EntityDespawnEvent->isHuman()`
+  - `EntityDespawnEvent->isProjectile()`
+  - `EntityDespawnEvent->isVehicle()`
+  - `EntityDespawnEvent->isItem()`
+  - `EntitySpawnEvent->getType()`
+  - `EntitySpawnEvent->getPosition()`
+  - `EntitySpawnEvent->isCreature()`
+  - `EntitySpawnEvent->isHuman()`
+  - `EntitySpawnEvent->isProjectile()`
+  - `EntitySpawnEvent->isVehicle()`
+  - `EntitySpawnEvent->isItem()`
+- Added the following API methods:
+  - `EntityDeathEvent->getXpDropAmount()`
+  - `EntityDeathEvent->setXpDropAmount()`
+- `PlayerDeathEvent::__construct()` now accepts a fourth (optional) parameter `int $xp`.
+- `EntityDeathEvent::__construct()` now accepts a third (optional) parameter `int $xp`.
+
+### Inventory
+- The following classes have been deprecated:
+  - `Recipe`
+- The following methods have been deprecated:
+  - `CraftingManager->registerRecipe()`
+  - `Recipe->registerToCraftingManager()` (and all its implementations)
+
+### Item
+- New `Enchantment` type ID constants have been added.
+- `ItemFactory::fromStringSingle()` has been added. This works exactly the same as `ItemFactory::fromString()`, but it has a return type of `Item` instead of `Item|Item[]` (more static analysis friendly).
+
+### Level
+- Added the following API methods:
+  - `Position->getLevelNonNull()`: this is the same as `Position->getLevel()`, but throws an `AssumptionFailedError` if the level is null or invalid (more static analysis friendly).
+  - `Level->getTimeOfDay()`
+- The following constants have been changed:
+  - `Level::TIME_DAY` now has a value of `1000`
+  - `Level::TIME_NIGHT` now has a value of `13000`
+- Added the following constants:
+  - `Level::TIME_MIDNIGHT`
+  - `Level::TIME_NOON`
+- The following types of particles now accept optional `Color` parameters in the constructor:
+  - `EnchantParticle`
+  - `InstantEnchantParticle`
+
+### Network
+- Added the following API methods:
+  - `RakLibInterface->setPacketLimit()`
+
+### Scheduler
+AsyncTask thread-local storage has been improved, making it simpler and easier to use.
+- `AsyncTask->fetchLocal()` no longer deletes stored thread-local data. Instead, the storage behaves more like properties, and gets deleted when the AsyncTask object goes out of scope.
+- `AsyncTask->peekLocal()` has been `@deprecated` (use `fetchLocal()` instead).
+- Notices are no longer emitted if an async task doesn't fetch its locally stored data.
+- The following methods have been deprecated:
+  - `AsyncTask->getFromThreadStore()` (use its worker's corresponding method)
+  - `AsyncTask->saveToThreadStore()` (use its worker's corresponding method)
+  - `AsyncTask->removeFromThreadStore()` (use its worker's corresponding method)
+
+### Utils
+- The following functions have been deprecated and have recommended replacements:
+  - `Utils::getMemoryUsage()` -> split into `Process::getMemoryUsage()` and `Process::getAdvancedMemoryUsage()` (not 1:1 replacement!!)
+  - `Utils::getRealMemoryUsage()` -> `Process::getRealMemoryUsage()`
+  - `Utils::getThreadCount()` -> `Process::getThreadCount()`
+  - `Utils::kill()` -> `Process::kill()`
+  - `Utils::execute()` -> `Process::execute()`
+- Added the following constants:
+  - `Utils::OS_WINDOWS`
+  - `Utils::OS_IOS`
+  - `Utils::OS_MACOS`
+  - `Utils::OS_ANDROID`
+  - `Utils::OS_LINUX`
+  - `Utils::OS_BSD`
+  - `Utils::OS_UNKNOWN`
+- Added the following API methods:
+  - `Config->getPath()`
+  - `Utils::recursiveUnlink()`
+  - `Terminal::write()`
+  - `Terminal::writeLine()`
+
+# 3.13.1
+- Fixed issues with `server.lock` not being unlocked on some platforms. Now, the server explicitly releases it before exiting.
+- `/timings` now sends a usage message when using an unknown subcommand. Previously, it would just give no output.
+- `/whitelist` now sends a usage message when using an unknown subcommand. Previously, it would just give no output.
+- The output from `/timings` is now broadcasted on the `pocketmine.broadcast.admin` broadcast channel for auditability, similarly to other operator commands.
+- Fixed `ShapedRecipe` deprecation warning on PHP 7.4.
+- Fixed some potential crashes with Bedrock worlds when chunk data is corrupted or missing.
+- Fixed a bug in region handling that caused region loaders to overestimate the amount of space used in the file. This resulted in an up to 4 MB growth of the file size every time the region was reloaded after writing a chunk.
+- Region handlers now try to reuse free space in region files before putting the chunk at the end of the file. Previously, space was only reused if the new version of the chunk was <= the size of the old. This fixes endless growth of region files.
+- Regions now never directly overwrite old copies of chunks when saving; instead they try to find an alternative location (preferring unused space within the file first). This avoids chunk corruption on power failure (the old copy of the chunk won't be damaged, so a rollback might occur instead), and as happy side effect, causes oversized regions to gradually shrink towards their most packed state over time, saving disk space.
+- Regions now have a hard size cap at 64 GB. This is because the header pointers will overflow beyond 64 GB (besides, a normal region shouldn't be this big anyway).
+- Fixed a crash that could occur when reading a too-short region header.
+- `VerifyLoginTask` now only copies JWTs to verify instead of the entire login packet. This reduces the amount of data copied between threads, improving performance.
+- Added a fast-fail check to `VerifyLoginTask` by checking the JWT header's `x5u` against the expected public key.
+- `Skin->validate()` now throws `InvalidSkinException` instead of `\InvalidArgumentException`.
+- A debug message is now logged when a player is kicked for having an invalid skin, giving a brief line of detail why.
+- Fixed players not being kicked for having an invalid `resourcePatch`.
+- Fixed block meta value of cake being preserved when using pick-block.
+- Fixed explosions not fully destroying multi-block objects like beds and doors.

changelogs/3.14.md

@@ -0,0 +1,40 @@
+**For Minecraft: Bedrock Edition 1.16.0**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.14.0
+- Added support for Minecraft: Bedrock Edition 1.16.0.
+- Removed compatibility with 1.14.60.
+
+## Known issues (please don't open issues for these)
+- Walls don't connect to each other
+- Pumpkin and melon stems may not connect to their corresponding pumpkin/melon
+- New blocks, items & mobs aren't implemented
+- Nether doesn't exist
+
+# 3.14.1
+- All skins are now trusted, bypassing the client-side trusted skin setting. Note that this means that NSFW skin filtering will **not** apply.
+- Fixed projectile motion being altered by ladders.
+- Fixed client-sided crashes when pressing E repeatedly very quickly on a high-latency connection.
+- `/plugins`, `/whitelist list`, `/banlist` and `/list` now show output in alphabetical order.
+- Some `pocketmine\event` APIs which accept arrays now have more robust type checking, fixing type errors caused by plugin input occurring in core code.
+- `Attribute::getAttributeByName()` is now aware of the `minecraft:lava_movement` attribute.
+
+# 3.14.2
+- Exception stack traces are now logged as CRITICAL. It's hoped that users will recognize that they are just as important as the error message and not leave them out when asking for help with errors on Discord.
+- `TaskScheduler` no longer accepts tasks that already have a handler. This fixes undefined behaviour which occurs when scheduling the same task instance twice, but it does break plugins such as **MyPlot** which unintentionally used this buggy behaviour.
+- Players will now correctly receive the needed number of spawn chunks if they are teleported between `PlayerLoginEvent` and `PlayerJoinEvent`. This fixes a bug that could occur when teleporting players in delayed tasks between login and join.
+- `PlayerRespawnEvent->setRespawnPosition()` now throws an exception if the provided `Position` has an invalid world associated with it (null or unloaded).
+- Fixed a crash that occurred when stats reporting was enabled.
+
+# 3.14.3
+- Fixed deprecation error when running `/whitelist list` on PHP 7.4.
+- Fixed podzol breaking animation being incorrect (incorrect hardness).
+- `Entity::getSaveId()` now reports the class name in the message thrown for unregistered entities.
+- Fixed `CraftingManager->validate()` producing different results when called multiple times for the same transaction.
+- Fixed various issues with batch-crafting items using the recipe book and shift-clicking.
+- `tests/plugins/PocketMine-DevTools` submodule has been renamed to `tests/plugins/DevTools`.

changelogs/3.15.md

@@ -0,0 +1,54 @@
+**For Minecraft: Bedrock Edition 1.16.20**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.15.0
+- Added support for Minecraft: Bedrock Edition 1.16.20.
+- Removed compatibility with 1.16.0.
+
+## Known issues (please don't open issues for these)
+- Walls don't connect to each other
+- Pumpkin and melon stems may not connect to their corresponding pumpkin/melon
+- New blocks, items & mobs aren't implemented
+- Nether doesn't exist
+
+# 3.15.1
+- Fixed various PHP 7.4 compatibility issues in Composer dependencies (primarily callback-validator).
+- Fixed LevelDB worlds with corrupted `level.dat` crashing the server instead of failing gracefully.
+- Fixed error spam when using strings for layers in flatworld presets (`e.g. bedrock,3xdirt,grass`).
+- Fixed blocks not getting updated properly on explosions.
+- Fixed `BlockGrowEvent` not being called when sugarcane grows.
+- Potato crops now drop poisonous potatoes when harvested.
+- Fixed the wrong number of potatoes being dropped when harvesting potato crops.
+- Players no longer get pullbacks when sprinting on slabs, stairs and various other blocks when `player.anti-cheat.allow-movement-cheats` is set to `false`. (This bug has been around for over 5 years, so many of you will be used to its existence.)
+- Fixed entity collision box calculation not taking clip distance into account.
+- Entities now step up the correct height of the target block, instead of jumping into the air 0.6 blocks and falling back down.
+
+# 3.15.2
+- Fixed issues with preloading `SubChunk`.
+- `/gc` and automatic garbage collection will now release unused heap blocks back to the OS. Previously, the PHP process might hold onto these blocks indefinitely even when not used, causing elevated real memory usage.
+- Added some documentation to `FurnaceBurnEvent`.
+
+# 3.15.3
+- Fixed fall damage accumulation over continuous knockbacks (e.g. combo attacks in PvP).
+- Fixed a bug in `Human->addXp()` that would cause a crash when saving player data.
+- `Human->addXp()` will no longer modify the target's total XP if `PlayerExperienceChangeEvent` was cancelled.
+- `AsyncPool->getTaskQueueSizes()` has been added to allow external detection of async pool overload. This is planned to be implemented as a core feature in the future, but it hasn't been done yet.
+- `BaseInventory->canAddItem()` behaviour now matches `addItem()` by considering the max stack size of the given item.
+- Fixed a bug in generator options handling for worlds loaded via `pocketmine.yml`. This fix has the following side effects:
+  - It's now possible to provide generator options as an `options` key when loading a world via `pocketmine.yml`.
+  - If generator options are not provided, the options from `server.properties` will be used, instead of using an empty preset. (It's not clear whether this is desired behaviour, but it was clearly intended, since there is code to do this which was broken until this release. As such, this behaviour is subject to change in the future.)
+- Fixed a bug in region-based world loading where some files without filename extensions and names containing a region filename extension (e.g a file named `amca` in a McRegion world) would cause the world not to load. These files are now ignored.
+- Default network compression level has been lowered to 6, due to level 7 being 25% more expensive for only a marginal improvement in bandwidth.
+- Fixed a performance issue with chunk requesting when players trigger chunk generation on first join.
+- Setup wizard will now always show IP information, even if the user chose to skip the setup wizard when prompted. (This doesn't affect `--no-wizard` in any way.)
+- `Maximum memory (system)` is no longer reported in `/status` due to having a misleading output (it was the same as the current memory usage).
+- The `Player Chunk Send` timer on timings reports now actually reports measurements of chunk sending, not chunk loading.
+- A new parent timer `World Load` has been added to timings reports, which aggregates timings from `syncChunkLoad` and subtimings from all worlds.
+
+# 3.15.4
+- Fixed a bug in the inventory transaction system that caused the server to freeze under some circumstances.

changelogs/3.16.md

@@ -0,0 +1,24 @@
+**For Minecraft: Bedrock Edition 1.16.100**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.16.0
+- Added support for Minecraft: Bedrock Edition 1.16.100.
+- Removed compatibility with earlier versions.
+- Added new custom composer commands `make-server` and `make-devtools` to ease setting up a development environment and building the server.
+
+## Known issues (please don't open issues for these)
+- Walls don't connect to each other
+- Pumpkin and melon stems may not connect to their corresponding pumpkin/melon
+- New blocks, items & mobs aren't implemented
+- Nether doesn't exist
+
+# 3.16.1
+- Fixed incorrect encoding of skins in the protocol.
+- `/version` no longer crashes when a plugin provides `string[]` for the `author` field in `plugin.yml`.
+- `author` in `plugin.yml` now accepts arrays, just like `authors`.
+- Fixed `HellBiome` never being registered.

changelogs/3.17.md

@@ -0,0 +1,23 @@
+**For Minecraft: Bedrock Edition 1.16.200**
+
+### Note about API versions
+Plugins which don't touch the protocol and compatible with any previous 3.x.y version will also run on these releases and do not need API bumps.
+Plugin developers should **only** update their required API to this version if you need the changes in this build.
+
+**WARNING: If your plugin uses the protocol, you're not shielded by API change constraints.** You should consider using the `mcpe-protocol` directive in `plugin.yml` as a constraint if you do.
+
+# 3.17.0
+- Added support for Minecraft: Bedrock Edition 1.16.200.
+- Removed compatibility with earlier versions.
+
+## Known issues (please don't open issues for these)
+- Walls don't connect to each other
+- Pumpkin and melon stems may not connect to their corresponding pumpkin/melon
+- New blocks, items & mobs aren't implemented
+- Nether doesn't exist
+
+# 3.17.1
+- Fixed some instances of plugin-caused crashes not being detected (eval()'d code, custom plugin paths).
+- Server uptime is now included in crash reports.
+- Hoes now take damage when used to break sponges.
+- Using lava as fuel in a furnace now leaves behind an empty bucket.

composer.json

@@ -5,9 +5,8 @@
    "homepage": "https://pmmp.io",
    "license": "LGPL-3.0",
    "require": {
-      "php": ">=7.2.0",
+      "php": ">=7.3.0",
       "php-64bit": "*",
-      "ext-bcmath": "*",
       "ext-curl": "*",
       "ext-ctype": "*",
       "ext-date": "*",
@@ -24,14 +23,24 @@
       "ext-yaml": ">=2.0.0",
       "ext-zip": "*",
       "ext-zlib": ">=1.2.11",
-      "pocketmine/raklib": "^0.12.5",
-      "pocketmine/spl": "^0.3.5",
+      "pocketmine/raklib": "^0.12.7",
+      "pocketmine/spl": "^0.4.0",
       "pocketmine/binaryutils": "^0.1.9",
       "pocketmine/nbt": "^0.2.10",
       "pocketmine/math": "^0.2.0",
       "pocketmine/snooze": "^0.1.0",
-      "daverandom/callback-validator": "dev-master",
-      "adhocore/json-comment": "^0.0.7"
+      "pocketmine/classloader": "^0.1.0",
+      "pocketmine/log": "^0.2.0",
+      "pocketmine/log-pthreads": "^0.1.0",
+      "pocketmine/callback-validator": "^1.0.2",
+      "adhocore/json-comment": "^0.1.0",
+      "composer-runtime-api": "^2.0"
+   },
+   "require-dev": {
+      "phpstan/phpstan": "0.12.64",
+      "phpstan/phpstan-phpunit": "^0.12.6",
+      "phpstan/phpstan-strict-rules": "^0.12.2",
+      "phpunit/phpunit": "^9.2"
    },
    "autoload": {
       "psr-4": {
@@ -48,30 +57,16 @@
          "pocketmine\\": "tests/phpunit/"
       }
    },
-   "repositories": [
-      {
-         "type": "vcs",
-         "url": "https://github.com/pmmp/RakLib"
-      },
-      {
-         "type": "vcs",
-         "url": "https://github.com/pmmp/SPL"
-      },
-      {
-         "type": "vcs",
-         "url": "https://github.com/pmmp/BinaryUtils"
-      },
-      {
-         "type": "vcs",
-         "url": "https://github.com/pmmp/NBT"
-      },
-      {
-         "type": "vcs",
-         "url": "https://github.com/pmmp/Math"
-      },
-      {
-         "type": "vcs",
-         "url": "https://github.com/pmmp/Snooze"
+   "config": {
+      "platform": {
+         "php": "7.3.0"
       }
-   ]
+   },
+   "scripts": {
+      "make-devtools": "@php -dphar.readonly=0 tests/plugins/DevTools/src/DevTools/ConsoleScript.php --make tests/plugins/DevTools --out plugins/DevTools.phar",
+      "make-server": [
+         "@composer install --no-dev --classmap-authoritative",
+         "@php -dphar.readonly=0 build/server-phar.php"
+      ]
+   }
 }

doxygen/index.md

@@ -5,6 +5,6 @@ This site contains auto-generated API documentation for PocketMine-MP (and depen
 This site can be accessed via https://apidoc.pmmp.io.
 
 ### Additional developer resources
- - [DevTools](https://github.com/pmmp/PocketMine-DevTools/) - Development tools plugin for creating plugins
+ - [DevTools](https://github.com/pmmp/DevTools/) - Development tools plugin for creating plugins
  - [ExamplePlugin](https://github.com/pmmp/ExamplePlugin/) - Example plugin demonstrating some basic API features
  - [DeveloperDocs](https://github.com/pmmp/DeveloperDocs/) - Reference, guides and specifications for the PocketMine-MP API

phpstan.neon.dist

@@ -1,118 +1,43 @@
 includes:
+	- tests/phpstan/configs/actual-problems.neon
+	- tests/phpstan/configs/check-explicit-mixed-baseline.neon
 	- tests/phpstan/configs/com-dotnet-magic.neon
-	- tests/phpstan/configs/custom-leveldb.neon
 	- tests/phpstan/configs/gc-hacks.neon
+	- tests/phpstan/configs/l7-baseline.neon
+	- tests/phpstan/configs/l8-baseline.neon
+	- tests/phpstan/configs/php-bugs.neon
 	- tests/phpstan/configs/phpstan-bugs.neon
+	- tests/phpstan/configs/phpunit-wiring-tests.neon
 	- tests/phpstan/configs/pthreads-bugs.neon
 	- tests/phpstan/configs/runtime-type-checks.neon
+	- vendor/phpstan/phpstan-phpunit/extension.neon
+	- vendor/phpstan/phpstan-phpunit/rules.neon
+	- vendor/phpstan/phpstan-strict-rules/rules.neon
 
 parameters:
-	level: 6
-	autoload_files:
+	level: 8
+	checkExplicitMixed: true
+	bootstrapFiles:
 		- tests/phpstan/bootstrap.php
+	scanDirectories:
+	    - tests/plugins/TesterPlugin
+	scanFiles:
 		- src/pocketmine/PocketMine.php
+		- build/make-release.php
 		- build/server-phar.php
 	paths:
 		- src
+		- build/make-release.php
 		- build/server-phar.php
+		- tests/phpunit
+		- tests/plugins/TesterPlugin
 	dynamicConstantNames:
 		- pocketmine\IS_DEVELOPMENT_BUILD
 		- pocketmine\DEBUG
+	stubFiles:
+		- tests/phpstan/stubs/pthreads.stub
+		- tests/phpstan/stubs/chunkutils.stub
+		- tests/phpstan/stubs/leveldb.stub
 	reportUnmatchedIgnoredErrors: false #no other way to silence platform-specific non-warnings
-	checkMissingIterableValueType: false #TODO: pthreads Threaded base for too many things, fix this later
-	ignoreErrors:
-		-
-			message: "#^Cannot instantiate interface pocketmine\\\\level\\\\format\\\\io\\\\LevelProvider\\.$#"
-			count: 1
-			path: src/pocketmine/Server.php
-
-		-
-			message: "#^Call to an undefined method pocketmine\\\\command\\\\CommandSender\\:\\:teleport\\(\\)\\.$#"
-			count: 1
-			path: src/pocketmine/command/defaults/TeleportCommand.php
-#			comment: "not actually possible, but high cost to fix warning"
-
-		-
-			message: "#^Array \\(array\\<string\\>\\) does not accept pocketmine\\\\entity\\\\Entity\\.$#"
-			count: 2
-			path: src/pocketmine/entity/Entity.php
-
-		-
-			message: "#^Invalid array key type pocketmine\\\\entity\\\\Entity\\.$#"
-			count: 1
-			path: src/pocketmine/entity/Entity.php
-
-		-
-			message: "#^Method pocketmine\\\\event\\\\entity\\\\EntityDeathEvent\\:\\:getEntity\\(\\) should return pocketmine\\\\entity\\\\Living but returns pocketmine\\\\entity\\\\Entity\\.$#"
-			count: 1
-			path: src/pocketmine/event/entity/EntityDeathEvent.php
-
-		-
-			message: "#^Method pocketmine\\\\event\\\\entity\\\\EntityShootBowEvent\\:\\:getEntity\\(\\) should return pocketmine\\\\entity\\\\Living but returns pocketmine\\\\entity\\\\Entity\\.$#"
-			count: 1
-			path: src/pocketmine/event/entity/EntityShootBowEvent.php
-
-		-
-			message: "#^Property pocketmine\\\\event\\\\entity\\\\EntityShootBowEvent\\:\\:\\$projectile \\(pocketmine\\\\entity\\\\projectile\\\\Projectile\\) does not accept pocketmine\\\\entity\\\\Entity\\.$#"
-			count: 1
-			path: src/pocketmine/event/entity/EntityShootBowEvent.php
-
-		-
-			message: "#^Method pocketmine\\\\event\\\\entity\\\\ItemDespawnEvent\\:\\:getEntity\\(\\) should return pocketmine\\\\entity\\\\object\\\\ItemEntity but returns pocketmine\\\\entity\\\\Entity\\.$#"
-			count: 1
-			path: src/pocketmine/event/entity/ItemDespawnEvent.php
-
-		-
-			message: "#^Method pocketmine\\\\event\\\\entity\\\\ItemSpawnEvent\\:\\:getEntity\\(\\) should return pocketmine\\\\entity\\\\object\\\\ItemEntity but returns pocketmine\\\\entity\\\\Entity\\.$#"
-			count: 1
-			path: src/pocketmine/event/entity/ItemSpawnEvent.php
-
-		-
-			message: "#^Method pocketmine\\\\event\\\\entity\\\\ProjectileHitEvent\\:\\:getEntity\\(\\) should return pocketmine\\\\entity\\\\projectile\\\\Projectile but returns pocketmine\\\\entity\\\\Entity\\.$#"
-			count: 1
-			path: src/pocketmine/event/entity/ProjectileHitEvent.php
-
-		-
-			message: "#^Method pocketmine\\\\event\\\\entity\\\\ProjectileLaunchEvent\\:\\:getEntity\\(\\) should return pocketmine\\\\entity\\\\projectile\\\\Projectile but returns pocketmine\\\\entity\\\\Entity\\.$#"
-			count: 1
-			path: src/pocketmine/event/entity/ProjectileLaunchEvent.php
-
-		-
-			message: "#^Constructor of class pocketmine\\\\level\\\\generator\\\\hell\\\\Nether has an unused parameter \\$options\\.$#"
-			count: 1
-			path: src/pocketmine/level/generator/hell/Nether.php
-
-		-
-			message: "#^Constructor of class pocketmine\\\\level\\\\generator\\\\normal\\\\Normal has an unused parameter \\$options\\.$#"
-			count: 1
-			path: src/pocketmine/level/generator/normal/Normal.php
-
-		-
-			message: "#^Constructor of class pocketmine\\\\scheduler\\\\TaskScheduler has an unused parameter \\$logger\\.$#"
-			count: 1
-			path: src/pocketmine/scheduler/TaskScheduler.php
-
-		-
-			message: "#^Constant pocketmine\\\\COMPOSER_AUTOLOADER_PATH not found\\.$#"
-			path: src
-
-		-
-			message: "#^Constant pocketmine\\\\DATA not found\\.$#"
-			path: src
-
-		-
-			message: "#^Constant pocketmine\\\\GIT_COMMIT not found\\.$#"
-			path: src
-
-		-
-			message: "#^Constant pocketmine\\\\PLUGIN_PATH not found\\.$#"
-			path: src
-
-		-
-			message: "#^Constant pocketmine\\\\START_TIME not found\\.$#"
-			path: src
-
-		-
-			message: "#^Constant pocketmine\\\\VERSION not found\\.$#"
-			path: src
-
+	staticReflectionClassNamePatterns:
+		- "#^COM$#"

src/pocketmine/Achievement.php

@@ -30,9 +30,7 @@ use pocketmine\utils\TextFormat;
  * Handles the achievement list and a bit more
  */
 abstract class Achievement{
-	/**
-	 * @var array[]
-	 */
+	/** @var array[] */
 	public static $list = [
 		/*"openInventory" => array(
 			"name" => "Taking Inventory",
@@ -106,13 +104,6 @@ abstract class Achievement{
 
 	];
 
-
-	/**
-	 * @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]);
@@ -129,11 +120,7 @@ abstract class Achievement{
 	}
 
 	/**
-	 * @param string $achievementId
-	 * @param string $achievementName
-	 * @param array  $requires
-	 *
-	 * @return bool
+	 * @param string[] $requires
 	 */
 	public static function add(string $achievementId, string $achievementName, array $requires = []) : bool{
 		if(!isset(Achievement::$list[$achievementId])){

src/pocketmine/CoreConstants.php

@@ -23,6 +23,10 @@ declare(strict_types=1);
 
 namespace pocketmine;
 
+use function define;
+use function defined;
+use function dirname;
+
 // composer autoload doesn't use require_once and also pthreads can inherit things
 if(defined('pocketmine\_CORE_CONSTANTS_INCLUDED')){
 	return;
@@ -30,4 +34,4 @@ if(defined('pocketmine\_CORE_CONSTANTS_INCLUDED')){
 define('pocketmine\_CORE_CONSTANTS_INCLUDED', true);
 
 define('pocketmine\PATH', dirname(__DIR__, 2) . '/');
-define('pocketmine\RESOURCE_PATH', __DIR__ . '/resources/');
+define('pocketmine\RESOURCE_PATH', __DIR__ . '/resources/');

src/pocketmine/CrashDump.php

@@ -23,13 +23,14 @@ declare(strict_types=1);
 
 namespace pocketmine;
 
+use Composer\InstalledVersions;
 use pocketmine\network\mcpe\protocol\ProtocolInfo;
 use pocketmine\plugin\PluginBase;
 use pocketmine\plugin\PluginLoadOrder;
 use pocketmine\plugin\PluginManager;
+use pocketmine\utils\AssumptionFailedError;
 use pocketmine\utils\Utils;
 use pocketmine\utils\VersionString;
-use raklib\RakLib;
 use function base64_encode;
 use function date;
 use function error_get_last;
@@ -46,6 +47,7 @@ use function is_resource;
 use function json_encode;
 use function json_last_error_msg;
 use function max;
+use function microtime;
 use function mkdir;
 use function ob_end_clean;
 use function ob_get_contents;
@@ -54,10 +56,10 @@ use function php_uname;
 use function phpinfo;
 use function phpversion;
 use function preg_replace;
+use function sprintf;
 use function str_split;
 use function strpos;
 use function substr;
-use function time;
 use function zend_version;
 use function zlib_encode;
 use const E_COMPILE_ERROR;
@@ -88,7 +90,7 @@ class CrashDump{
 	 * having their content changed, version format changing, etc.
 	 * It is not necessary to increase this when adding new fields.
 	 */
-	private const FORMAT_VERSION = 2;
+	private const FORMAT_VERSION = 4;
 
 	private const PLUGIN_INVOLVEMENT_NONE = "none";
 	private const PLUGIN_INVOLVEMENT_DIRECT = "direct";
@@ -98,9 +100,12 @@ class CrashDump{
 	private $server;
 	/** @var resource */
 	private $fp;
-	/** @var int */
+	/** @var float */
 	private $time;
-	/** @var mixed[] */
+	/**
+	 * @var mixed[]
+	 * @phpstan-var array<string, mixed>
+	 */
 	private $data = [];
 	/** @var string */
 	private $encodedData = "";
@@ -108,19 +113,21 @@ class CrashDump{
 	private $path;
 
 	public function __construct(Server $server){
-		$this->time = time();
+		$this->time = microtime(true);
 		$this->server = $server;
 		if(!is_dir($this->server->getDataPath() . "crashdumps")){
 			mkdir($this->server->getDataPath() . "crashdumps");
 		}
-		$this->path = $this->server->getDataPath() . "crashdumps/" . date("D_M_j-H.i.s-T_Y", $this->time) . ".log";
-		$this->fp = @fopen($this->path, "wb");
-		if(!is_resource($this->fp)){
+		$this->path = $this->server->getDataPath() . "crashdumps/" . date("D_M_j-H.i.s-T_Y", (int) $this->time) . ".log";
+		$fp = @fopen($this->path, "wb");
+		if(!is_resource($fp)){
 			throw new \RuntimeException("Could not create Crash Dump");
 		}
+		$this->fp = $fp;
 		$this->data["format_version"] = self::FORMAT_VERSION;
 		$this->data["time"] = $this->time;
-		$this->addLine($this->server->getName() . " Crash Dump " . date("D M j H:i:s T Y", $this->time));
+		$this->data["uptime"] = $this->time - \pocketmine\START_TIME;
+		$this->addLine($this->server->getName() . " Crash Dump " . date("D M j H:i:s T Y", (int) $this->time));
 		$this->addLine();
 		$this->baseCrash();
 		$this->generalData();
@@ -144,6 +151,10 @@ class CrashDump{
 		return $this->encodedData;
 	}
 
+	/**
+	 * @return mixed[]
+	 * @phpstan-return array<string, mixed>
+	 */
 	public function getData() : array{
 		return $this->data;
 	}
@@ -157,7 +168,9 @@ class CrashDump{
 		if($json === false){
 			throw new \RuntimeException("Failed to encode crashdump JSON: " . json_last_error_msg());
 		}
-		$this->encodedData = zlib_encode($json, ZLIB_ENCODING_DEFLATE, 9);
+		$zlibEncoded = zlib_encode($json, ZLIB_ENCODING_DEFLATE, 9);
+		if($zlibEncoded === false) throw new AssumptionFailedError("ZLIB compression failed");
+		$this->encodedData = $zlibEncoded;
 		foreach(str_split(base64_encode($this->encodedData), 76) as $line){
 			$this->addLine($line);
 		}
@@ -221,7 +234,10 @@ class CrashDump{
 		if(isset($lastExceptionError)){
 			$error = $lastExceptionError;
 		}else{
-			$error = (array) error_get_last();
+			$error = error_get_last();
+			if($error === null){
+				throw new \RuntimeException("Crash error information missing - did something use exit()?");
+			}
 			$error["trace"] = Utils::currentTrace(3); //Skipping CrashDump->baseCrash, CrashDump->construct, Server->crashDump
 			$errorConversion = [
 				E_ERROR => "E_ERROR",
@@ -281,9 +297,11 @@ class CrashDump{
 
 		if($this->server->getProperty("auto-report.send-code", true) !== false and file_exists($error["fullFile"])){
 			$file = @file($error["fullFile"], FILE_IGNORE_NEW_LINES);
-			for($l = max(0, $error["line"] - 10); $l < $error["line"] + 10 and isset($file[$l]); ++$l){
-				$this->addLine("[" . ($l + 1) . "] " . $file[$l]);
-				$this->data["code"][$l + 1] = $file[$l];
+			if($file !== false){
+				for($l = max(0, $error["line"] - 10); $l < $error["line"] + 10 and isset($file[$l]); ++$l){
+					$this->addLine("[" . ($l + 1) . "] " . $file[$l]);
+					$this->data["code"][$l + 1] = $file[$l];
+				}
 			}
 		}
 
@@ -296,8 +314,8 @@ class CrashDump{
 	}
 
 	private function determinePluginFromFile(string $filePath, bool $crashFrame) : bool{
-		$frameCleanPath = Utils::cleanPath($filePath); //this will be empty in phar stub
-		if(strpos($frameCleanPath, "plugins") === 0 and file_exists($filePath)){
+		$frameCleanPath = Utils::cleanPath($filePath);
+		if(strpos($frameCleanPath, Utils::CLEAN_PATH_SRC_PREFIX) !== 0){
 			$this->addLine();
 			if($crashFrame){
 				$this->addLine("THIS CRASH WAS CAUSED BY A PLUGIN");
@@ -307,15 +325,17 @@ class CrashDump{
 				$this->data["plugin_involvement"] = self::PLUGIN_INVOLVEMENT_INDIRECT;
 			}
 
-			$reflection = new \ReflectionClass(PluginBase::class);
-			$file = $reflection->getProperty("file");
-			$file->setAccessible(true);
-			foreach($this->server->getPluginManager()->getPlugins() as $plugin){
-				$filePath = Utils::cleanPath($file->getValue($plugin));
-				if(strpos($frameCleanPath, $filePath) === 0){
-					$this->data["plugin"] = $plugin->getName();
-					$this->addLine("BAD PLUGIN: " . $plugin->getDescription()->getFullName());
-					break;
+			if(file_exists($filePath)){
+				$reflection = new \ReflectionClass(PluginBase::class);
+				$file = $reflection->getProperty("file");
+				$file->setAccessible(true);
+				foreach($this->server->getPluginManager()->getPlugins() as $plugin){
+					$filePath = Utils::cleanPath($file->getValue($plugin));
+					if(strpos($frameCleanPath, $filePath) === 0){
+						$this->data["plugin"] = $plugin->getName();
+						$this->addLine("BAD PLUGIN: " . $plugin->getDescription()->getFullName());
+						break;
+					}
 				}
 			}
 			return true;
@@ -325,6 +345,15 @@ class CrashDump{
 
 	private function generalData() : void{
 		$version = new VersionString(\pocketmine\BASE_VERSION, \pocketmine\IS_DEVELOPMENT_BUILD, \pocketmine\BUILD_NUMBER);
+		$composerLibraries = [];
+		foreach(InstalledVersions::getInstalledPackages() as $package){
+			$composerLibraries[$package] = sprintf(
+				"%s@%s",
+				InstalledVersions::getPrettyVersion($package) ?? "unknown",
+				InstalledVersions::getReference($package) ?? "unknown"
+			);
+		}
+
 		$this->data["general"] = [];
 		$this->data["general"]["name"] = $this->server->getName();
 		$this->data["general"]["base_version"] = \pocketmine\BASE_VERSION;
@@ -332,18 +361,22 @@ class CrashDump{
 		$this->data["general"]["is_dev"] = \pocketmine\IS_DEVELOPMENT_BUILD;
 		$this->data["general"]["protocol"] = ProtocolInfo::CURRENT_PROTOCOL;
 		$this->data["general"]["git"] = \pocketmine\GIT_COMMIT;
-		$this->data["general"]["raklib"] = RakLib::VERSION;
 		$this->data["general"]["uname"] = php_uname("a");
 		$this->data["general"]["php"] = phpversion();
 		$this->data["general"]["zend"] = zend_version();
 		$this->data["general"]["php_os"] = PHP_OS;
 		$this->data["general"]["os"] = Utils::getOS();
+		$this->data["general"]["composer_libraries"] = $composerLibraries;
 		$this->addLine($this->server->getName() . " version: " . $version->getFullVersion(true) . " [Protocol " . ProtocolInfo::CURRENT_PROTOCOL . "]");
 		$this->addLine("Git commit: " . \pocketmine\GIT_COMMIT);
 		$this->addLine("uname -a: " . php_uname("a"));
 		$this->addLine("PHP Version: " . phpversion());
 		$this->addLine("Zend version: " . zend_version());
 		$this->addLine("OS : " . PHP_OS . ", " . Utils::getOS());
+		$this->addLine("Composer libraries: ");
+		foreach($composerLibraries as $library => $libraryVersion){
+			$this->addLine("- $library $libraryVersion");
+		}
 	}
 
 	/**

src/pocketmine/GlobalConstants.php

@@ -19,6 +19,8 @@
  *
 */
 
+declare(strict_types=1);
+
 // composer autoload doesn't use require_once and also pthreads can inherit things
 if(defined('pocketmine\_GLOBAL_CONSTANTS_INCLUDED')){
 	return;

src/pocketmine/IPlayer.php

@@ -27,36 +27,20 @@ use pocketmine\permission\ServerOperator;
 
 interface IPlayer extends ServerOperator{
 
-	/**
-	 * @return bool
-	 */
 	public function isOnline() : bool;
 
-	/**
-	 * @return string
-	 */
 	public function getName() : string;
 
-	/**
-	 * @return bool
-	 */
 	public function isBanned() : bool;
 
 	/**
-	 * @param bool $banned
-	 *
 	 * @return void
 	 */
 	public function setBanned(bool $banned);
 
-	/**
-	 * @return bool
-	 */
 	public function isWhitelisted() : bool;
 
 	/**
-	 * @param bool $value
-	 *
 	 * @return void
 	 */
 	public function setWhitelisted(bool $value);
@@ -76,9 +60,6 @@ interface IPlayer extends ServerOperator{
 	 */
 	public function getLastPlayed();
 
-	/**
-	 * @return bool
-	 */
 	public function hasPlayedBefore() : bool;
 
 }

src/pocketmine/MemoryManager.php

@@ -27,6 +27,8 @@ use pocketmine\event\server\LowMemoryEvent;
 use pocketmine\scheduler\DumpWorkerMemoryTask;
 use pocketmine\scheduler\GarbageCollectionTask;
 use pocketmine\timings\Timings;
+use pocketmine\utils\AssumptionFailedError;
+use pocketmine\utils\Process;
 use pocketmine\utils\Utils;
 use function arsort;
 use function count;
@@ -38,6 +40,7 @@ use function fwrite;
 use function gc_collect_cycles;
 use function gc_disable;
 use function gc_enable;
+use function gc_mem_caches;
 use function get_class;
 use function get_declared_classes;
 use function implode;
@@ -48,6 +51,7 @@ use function is_object;
 use function is_resource;
 use function is_string;
 use function json_encode;
+use function mb_strtoupper;
 use function min;
 use function mkdir;
 use function preg_match;
@@ -56,7 +60,6 @@ use function round;
 use function spl_object_hash;
 use function sprintf;
 use function strlen;
-use function strtoupper;
 use function substr;
 use const JSON_PRETTY_PRINT;
 use const JSON_UNESCAPED_SLASHES;
@@ -125,7 +128,7 @@ class MemoryManager{
 			if($m <= 0){
 				$defaultMemory = 0;
 			}else{
-				switch(strtoupper($matches[2])){
+				switch(mb_strtoupper($matches[2])){
 					case "K":
 						$defaultMemory = $m / 1024;
 						break;
@@ -169,39 +172,24 @@ class MemoryManager{
 		gc_enable();
 	}
 
-	/**
-	 * @return bool
-	 */
 	public function isLowMemory() : bool{
 		return $this->lowMemory;
 	}
 
-	/**
-	 * @return bool
-	 */
 	public function canUseChunkCache() : bool{
 		return !$this->lowMemory or !$this->lowMemDisableChunkCache;
 	}
 
 	/**
 	 * Returns the allowed chunk radius based on the current memory usage.
-	 *
-	 * @param int $distance
-	 *
-	 * @return int
 	 */
 	public function getViewDistance(int $distance) : int{
-		return ($this->lowMemory and $this->lowMemChunkRadiusOverride > 0) ? (int) min($this->lowMemChunkRadiusOverride, $distance) : $distance;
+		return ($this->lowMemory and $this->lowMemChunkRadiusOverride > 0) ? min($this->lowMemChunkRadiusOverride, $distance) : $distance;
 	}
 
 	/**
 	 * Triggers garbage collection and cache cleanup to try and free memory.
 	 *
-	 * @param int  $memory
-	 * @param int  $limit
-	 * @param bool $global
-	 * @param int  $triggerCount
-	 *
 	 * @return void
 	 */
 	public function trigger(int $memory, int $limit, bool $global = false, int $triggerCount = 0){
@@ -240,7 +228,7 @@ class MemoryManager{
 
 		if(($this->memoryLimit > 0 or $this->globalMemoryLimit > 0) and ++$this->checkTicker >= $this->checkRate){
 			$this->checkTicker = 0;
-			$memory = Utils::getMemoryUsage(true);
+			$memory = Process::getAdvancedMemoryUsage();
 			$trigger = false;
 			if($this->memoryLimit > 0 and $memory[0] > $this->memoryLimit){
 				$trigger = 0;
@@ -272,9 +260,6 @@ class MemoryManager{
 		Timings::$memoryManagerTimer->stopTiming();
 	}
 
-	/**
-	 * @return int
-	 */
 	public function triggerGarbageCollector() : int{
 		Timings::$garbageCollectorTimer->startTiming();
 
@@ -289,6 +274,7 @@ class MemoryManager{
 		}
 
 		$cycles = gc_collect_cycles();
+		gc_mem_caches();
 
 		Timings::$garbageCollectorTimer->stopTiming();
 
@@ -298,10 +284,6 @@ class MemoryManager{
 	/**
 	 * Dumps the server memory into the specified output folder.
 	 *
-	 * @param string $outputFolder
-	 * @param int    $maxNesting
-	 * @param int    $maxStringSize
-	 *
 	 * @return void
 	 */
 	public function dumpServerMemory(string $outputFolder, int $maxNesting, int $maxStringSize){
@@ -320,16 +302,13 @@ class MemoryManager{
 	 * Static memory dumper accessible from any thread.
 	 *
 	 * @param mixed   $startingObject
-	 * @param string  $outputFolder
-	 * @param int     $maxNesting
-	 * @param int     $maxStringSize
-	 * @param \Logger $logger
 	 *
 	 * @return void
 	 * @throws \ReflectionException
 	 */
 	public static function dumpMemory($startingObject, string $outputFolder, int $maxNesting, int $maxStringSize, \Logger $logger){
 		$hardLimit = ini_get('memory_limit');
+		if($hardLimit === false) throw new AssumptionFailedError("memory_limit INI directive should always exist");
 		ini_set('memory_limit', '-1');
 		gc_disable();
 
@@ -363,7 +342,7 @@ class MemoryManager{
 				}
 
 				$staticCount++;
-				self::continueDump($property->getValue(), $staticProperties[$className][$property->getName()], $objects, $refCounts, 0, $maxNesting, $maxStringSize);
+				$staticProperties[$className][$property->getName()] = self::continueDump($property->getValue(), $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 			}
 
 			if(count($staticProperties[$className]) === 0){
@@ -396,14 +375,14 @@ class MemoryManager{
 				}
 
 				$globalCount++;
-				self::continueDump($value, $globalVariables[$varName], $objects, $refCounts, 0, $maxNesting, $maxStringSize);
+				$globalVariables[$varName] = self::continueDump($value, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 			}
 
 			file_put_contents($outputFolder . "/globalVariables.js", json_encode($globalVariables, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT));
 			$logger->info("[Dump] Wrote $globalCount global variables");
 		}
 
-		self::continueDump($startingObject, $data, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
+		$data = self::continueDump($startingObject, $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 
 		do{
 			$continue = false;
@@ -429,8 +408,8 @@ class MemoryManager{
 					"properties" => []
 				];
 
-				if($reflection->getParentClass()){
-					$info["parent"] = $reflection->getParentClass()->getName();
+				if(($parent = $reflection->getParentClass()) !== false){
+					$info["parent"] = $parent->getName();
 				}
 
 				if(count($reflection->getInterfaceNames()) > 0){
@@ -451,14 +430,13 @@ class MemoryManager{
 							$property->setAccessible(true);
 						}
 
-						self::continueDump($property->getValue($object), $info["properties"][$name], $objects, $refCounts, 0, $maxNesting, $maxStringSize);
+						$info["properties"][$name] = self::continueDump($property->getValue($object), $objects, $refCounts, 0, $maxNesting, $maxStringSize);
 					}
 				}
 
 				fwrite($obData, "$hash@$className: " . json_encode($info, JSON_UNESCAPED_SLASHES) . "\n");
 			}
 
-
 		}while($continue);
 
 		$logger->info("[Dump] Wrote " . count($objects) . " objects");
@@ -479,17 +457,14 @@ class MemoryManager{
 
 	/**
 	 * @param mixed    $from
-	 * @param mixed    $data reference parameter
 	 * @param object[] $objects reference parameter
 	 * @param int[]    $refCounts reference parameter
-	 * @param int      $recursion
-	 * @param int      $maxNesting
-	 * @param int      $maxStringSize
+	 *
+	 * @return mixed
 	 */
-	private static function continueDump($from, &$data, array &$objects, array &$refCounts, int $recursion, int $maxNesting, int $maxStringSize) : void{
+	private static function continueDump($from, array &$objects, array &$refCounts, int $recursion, int $maxNesting, int $maxStringSize){
 		if($maxNesting <= 0){
-			$data = "(error) NESTING LIMIT REACHED";
-			return;
+			return "(error) NESTING LIMIT REACHED";
 		}
 
 		--$maxNesting;
@@ -505,12 +480,11 @@ class MemoryManager{
 			$data = "(object) $hash@" . get_class($from);
 		}elseif(is_array($from)){
 			if($recursion >= 5){
-				$data = "(error) ARRAY RECURSION LIMIT REACHED";
-				return;
+				return "(error) ARRAY RECURSION LIMIT REACHED";
 			}
 			$data = [];
 			foreach($from as $key => $value){
-				self::continueDump($value, $data[$key], $objects, $refCounts, $recursion + 1, $maxNesting, $maxStringSize);
+				$data[$key] = self::continueDump($value, $objects, $refCounts, $recursion + 1, $maxNesting, $maxStringSize);
 			}
 		}elseif(is_string($from)){
 			$data = "(string) len(" . strlen($from) . ") " . substr(Utils::printable($from), 0, $maxStringSize);
@@ -519,5 +493,7 @@ class MemoryManager{
 		}else{
 			$data = $from;
 		}
+
+		return $data;
 	}
 }

src/pocketmine/OfflinePlayer.php

@@ -37,10 +37,6 @@ class OfflinePlayer implements IPlayer, Metadatable{
 	/** @var CompoundTag|null */
 	private $namedtag = null;
 
-	/**
-	 * @param Server $server
-	 * @param string $name
-	 */
 	public function __construct(Server $server, string $name){
 		$this->server = $server;
 		$this->name = $name;

src/pocketmine/PocketMine.php

@@ -25,6 +25,7 @@ namespace pocketmine {
 
 	use pocketmine\utils\Git;
 	use pocketmine\utils\MainLogger;
+	use pocketmine\utils\Process;
 	use pocketmine\utils\ServerKiller;
 	use pocketmine\utils\Terminal;
 	use pocketmine\utils\Timezone;
@@ -34,7 +35,7 @@ namespace pocketmine {
 
 	require_once __DIR__ . '/VersionInfo.php';
 
-	const MIN_PHP_VERSION = "7.2.0";
+	const MIN_PHP_VERSION = "7.3.0";
 
 	/**
 	 * @param string $message
@@ -72,7 +73,6 @@ namespace pocketmine {
 		}
 
 		$extensions = [
-			"bcmath" => "BC Math",
 			"curl" => "cURL",
 			"ctype" => "ctype",
 			"date" => "Date",
@@ -173,19 +173,18 @@ namespace pocketmine {
 
 		$opts = getopt("", ["bootstrap:"]);
 		if(isset($opts["bootstrap"])){
-			$bootstrap = realpath($opts["bootstrap"]) ?: $opts["bootstrap"];
+			$bootstrap = ($real = realpath($opts["bootstrap"])) !== false ? $real : $opts["bootstrap"];
 		}else{
 			$bootstrap = dirname(__FILE__, 3) . '/vendor/autoload.php';
 		}
-		define('pocketmine\COMPOSER_AUTOLOADER_PATH', $bootstrap);
 
-		if(\pocketmine\COMPOSER_AUTOLOADER_PATH !== false and is_file(\pocketmine\COMPOSER_AUTOLOADER_PATH)){
-			require_once(\pocketmine\COMPOSER_AUTOLOADER_PATH);
-		}else{
+		if($bootstrap === false or !is_file($bootstrap)){
 			critical_error("Composer autoloader not found at " . $bootstrap);
 			critical_error("Please install/update Composer dependencies or use provided builds.");
 			exit(1);
 		}
+		define('pocketmine\COMPOSER_AUTOLOADER_PATH', $bootstrap);
+		require_once(\pocketmine\COMPOSER_AUTOLOADER_PATH);
 
 		set_error_handler([Utils::class, 'errorExceptionHandler']);
 
@@ -263,7 +262,6 @@ namespace pocketmine {
 
 			//TODO: move this to a Server field
 			define('pocketmine\START_TIME', microtime(true));
-			ThreadManager::init();
 
 			/*
 			 * We now use the Composer autoloader, but this autoloader is still for loading plugins.
@@ -281,7 +279,7 @@ namespace pocketmine {
 
 			if(ThreadManager::getInstance()->stopAll() > 0){
 				$logger->debug("Some threads could not be stopped, performing a force-kill");
-				Utils::kill(getmypid());
+				Process::kill(Process::pid());
 			}
 		}while(false);
 
@@ -290,6 +288,14 @@ namespace pocketmine {
 
 		echo Terminal::$FORMAT_RESET . PHP_EOL;
 
+		if(!flock(\pocketmine\LOCK_FILE, LOCK_UN)){
+			critical_error("Failed to release the server.lock file.");
+		}
+
+		if(!fclose(\pocketmine\LOCK_FILE)){
+			critical_error("Could not close server.lock resource.");
+		}
+
 		exit($exitCode);
 	}
 

src/pocketmine/Thread.php

@@ -23,6 +23,8 @@ declare(strict_types=1);
 
 namespace pocketmine;
 
+use const PTHREADS_INHERIT_ALL;
+
 /**
  * This class must be extended by all custom threading classes
  */
@@ -44,8 +46,6 @@ abstract class Thread extends \Thread{
 	}
 
 	/**
-	 * @param \ClassLoader|null $loader
-	 *
 	 * @return void
 	 */
 	public function setClassLoader(\ClassLoader $loader = null){
@@ -76,11 +76,9 @@ abstract class Thread extends \Thread{
 	}
 
 	/**
-	 * @param int|null $options TODO: pthreads bug
-	 *
 	 * @return bool
 	 */
-	public function start(?int $options = \PTHREADS_INHERIT_ALL){
+	public function start(int $options = PTHREADS_INHERIT_ALL){
 		ThreadManager::getInstance()->add($this);
 
 		if($this->getClassLoader() === null){

src/pocketmine/ThreadManager.php

@@ -28,10 +28,11 @@ use function spl_object_hash;
 
 class ThreadManager extends \Volatile{
 
-	/** @var ThreadManager */
+	/** @var ThreadManager|null */
 	private static $instance = null;
 
 	/**
+	 * @deprecated
 	 * @return void
 	 */
 	public static function init(){
@@ -42,6 +43,9 @@ class ThreadManager extends \Volatile{
 	 * @return ThreadManager
 	 */
 	public static function getInstance(){
+		if(self::$instance === null){
+			self::$instance = new ThreadManager();
+		}
 		return self::$instance;
 	}
 
@@ -52,7 +56,7 @@ class ThreadManager extends \Volatile{
 	 */
 	public function add($thread){
 		if($thread instanceof Thread or $thread instanceof Worker){
-			$this->{spl_object_hash($thread)} = $thread;
+			$this[spl_object_hash($thread)] = $thread;
 		}
 	}
 
@@ -63,7 +67,7 @@ class ThreadManager extends \Volatile{
 	 */
 	public function remove($thread){
 		if($thread instanceof Thread or $thread instanceof Worker){
-			unset($this->{spl_object_hash($thread)});
+			unset($this[spl_object_hash($thread)]);
 		}
 	}
 

src/pocketmine/VersionInfo.php

@@ -23,6 +23,8 @@ declare(strict_types=1);
 
 namespace pocketmine;
 
+use function defined;
+
 // composer autoload doesn't use require_once and also pthreads can inherit things
 // TODO: drop this file and use a final class with constants
 if(defined('pocketmine\_VERSION_INFO_INCLUDED')){
@@ -30,8 +32,7 @@ if(defined('pocketmine\_VERSION_INFO_INCLUDED')){
 }
 const _VERSION_INFO_INCLUDED = true;
 
-
 const NAME = "PocketMine-MP";
-const BASE_VERSION = "3.11.4";
+const BASE_VERSION = "3.17.1";
 const IS_DEVELOPMENT_BUILD = false;
 const BUILD_NUMBER = 0;

src/pocketmine/Worker.php

@@ -23,6 +23,8 @@ declare(strict_types=1);
 
 namespace pocketmine;
 
+use const PTHREADS_INHERIT_ALL;
+
 /**
  * This class must be extended by all custom threading classes
  */
@@ -44,8 +46,6 @@ abstract class Worker extends \Worker{
 	}
 
 	/**
-	 * @param \ClassLoader|null $loader
-	 *
 	 * @return void
 	 */
 	public function setClassLoader(\ClassLoader $loader = null){
@@ -76,11 +76,9 @@ abstract class Worker extends \Worker{
 	}
 
 	/**
-	 * @param int|null $options TODO: pthreads bug
-	 *
 	 * @return bool
 	 */
-	public function start(?int $options = \PTHREADS_INHERIT_ALL){
+	public function start(int $options = PTHREADS_INHERIT_ALL){
 		ThreadManager::getInstance()->add($this);
 
 		if($this->getClassLoader() === null){

src/pocketmine/block/Air.php

@@ -26,7 +26,6 @@ namespace pocketmine\block;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
 
-
 /**
  * Air block
  */

src/pocketmine/block/Anvil.php

@@ -78,7 +78,7 @@ class Anvil extends Fallable{
 	public function recalculateBoundingBox() : ?AxisAlignedBB{
 		$inset = 0.125;
 
-		if($this->meta & 0x01){ //east/west
+		if(($this->meta & 0x01) !== 0){ //east/west
 			return new AxisAlignedBB(
 				$this->x,
 				$this->y,
@@ -110,6 +110,6 @@ class Anvil extends Fallable{
 	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);
+		return $this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 	}
 }

src/pocketmine/block/BaseRail.php

@@ -91,7 +91,7 @@ abstract class BaseRail extends Flowable{
 	}
 
 	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)){
+		if(!$blockReplace->getSide(Vector3::SIDE_DOWN)->isTransparent() and $this->getLevelNonNull()->setBlock($blockReplace, $this, true, true)){
 			$this->tryReconnect();
 			return true;
 		}
@@ -99,6 +99,11 @@ abstract class BaseRail extends Flowable{
 		return false;
 	}
 
+	/**
+	 * @param int[]   $connections
+	 * @param int[][] $lookup
+	 * @phpstan-param array<int, list<int>> $lookup
+	 */
 	protected static function searchState(array $connections, array $lookup) : int{
 		$meta = array_search($connections, $lookup, true);
 		if($meta === false){
@@ -114,9 +119,7 @@ abstract class BaseRail extends Flowable{
 	/**
 	 * Returns a meta value for the rail with the given connections.
 	 *
-	 * @param array $connections
-	 *
-	 * @return int
+	 * @param int[] $connections
 	 *
 	 * @throws \InvalidArgumentException if no state matches the given connections
 	 */
@@ -164,6 +167,12 @@ abstract class BaseRail extends Flowable{
 		return $connections;
 	}
 
+	/**
+	 * @param int[] $constraints
+	 *
+	 * @return true[]
+	 * @phpstan-return array<int, true>
+	 */
 	private function getPossibleConnectionDirections(array $constraints) : array{
 		switch(count($constraints)){
 			case 0:
@@ -188,6 +197,10 @@ abstract class BaseRail extends Flowable{
 		}
 	}
 
+	/**
+	 * @return true[]
+	 * @phpstan-return array<int, true>
+	 */
 	protected function getPossibleConnectionDirectionsOneConstraint(int $constraint) : array{
 		$opposite = Vector3::getOppositeSide($constraint & ~self::FLAG_ASCEND);
 
@@ -247,6 +260,9 @@ abstract class BaseRail extends Flowable{
 		}
 	}
 
+	/**
+	 * @param int[] $connections
+	 */
 	private function updateState(array $connections) : void{
 		if(count($connections) === 1){
 			$connections[] = Vector3::getOppositeSide($connections[0] & ~self::FLAG_ASCEND);
@@ -263,7 +279,7 @@ abstract class BaseRail extends Flowable{
 			isset(self::ASCENDING_SIDES[$this->meta & 0x07]) and
 			$this->getSide(self::ASCENDING_SIDES[$this->meta & 0x07])->isTransparent()
 		)){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}
 	}
 

src/pocketmine/block/Bed.php

@@ -69,16 +69,11 @@ class Bed extends Transparent{
 		return ($this->meta & self::BITFLAG_HEAD) !== 0;
 	}
 
-	/**
-	 * @return bool
-	 */
 	public function isOccupied() : bool{
 		return ($this->meta & self::BITFLAG_OCCUPIED) !== 0;
 	}
 
 	/**
-	 * @param bool $occupied
-	 *
 	 * @return void
 	 */
 	public function setOccupied(bool $occupied = true){
@@ -88,19 +83,13 @@ class Bed extends Transparent{
 			$this->meta &= ~self::BITFLAG_OCCUPIED;
 		}
 
-		$this->getLevel()->setBlock($this, $this, false, false);
+		$this->getLevelNonNull()->setBlock($this, $this, false, false);
 
 		if(($other = $this->getOtherHalf()) !== null and $other->isOccupied() !== $occupied){
 			$other->setOccupied($occupied);
 		}
 	}
 
-	/**
-	 * @param int  $meta
-	 * @param bool $isHead
-	 *
-	 * @return int
-	 */
 	public static function getOtherHalfSide(int $meta, bool $isHead = false) : int{
 		$rotation = $meta & 0x03;
 		$side = -1;
@@ -127,9 +116,6 @@ class Bed extends Transparent{
 		return $side;
 	}
 
-	/**
-	 * @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))){
@@ -151,7 +137,7 @@ class Bed extends Transparent{
 				return true;
 			}
 
-			$time = $this->getLevel()->getTime() % Level::TIME_FULL;
+			$time = $this->getLevelNonNull()->getTimeOfDay();
 
 			$isNight = ($time >= Level::TIME_NIGHT and $time < Level::TIME_SUNRISE);
 
@@ -182,11 +168,11 @@ class Bed extends Transparent{
 			$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);
+				$this->getLevelNonNull()->setBlock($blockReplace, BlockFactory::get($this->id, $meta), true, true);
+				$this->getLevelNonNull()->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));
+				Tile::createTile(Tile::BED, $this->getLevelNonNull(), TileBed::createNBT($this, $face, $item, $player));
+				Tile::createTile(Tile::BED, $this->getLevelNonNull(), TileBed::createNBT($next, $face, $item, $player));
 
 				return true;
 			}
@@ -208,7 +194,7 @@ class Bed extends Transparent{
 	}
 
 	private function getItem() : Item{
-		$tile = $this->getLevel()->getTile($this);
+		$tile = $this->getLevelNonNull()->getTile($this);
 		if($tile instanceof TileBed){
 			return ItemFactory::get($this->getItemId(), $tile->getColor());
 		}

src/pocketmine/block/Block.php

@@ -36,7 +36,7 @@ use pocketmine\math\RayTraceResult;
 use pocketmine\math\Vector3;
 use pocketmine\metadata\Metadatable;
 use pocketmine\metadata\MetadataValue;
-use pocketmine\network\mcpe\protocol\types\RuntimeBlockMapping;
+use pocketmine\network\mcpe\convert\RuntimeBlockMapping;
 use pocketmine\Player;
 use pocketmine\plugin\Plugin;
 use function array_merge;
@@ -50,12 +50,6 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * 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);
@@ -73,7 +67,6 @@ class Block extends Position implements BlockIds, Metadatable{
 	/** @var AxisAlignedBB|null */
 	protected $boundingBox = null;
 
-
 	/** @var AxisAlignedBB[]|null */
 	protected $collisionBoxes = null;
 
@@ -90,16 +83,10 @@ class Block extends Position implements BlockIds, Metadatable{
 		$this->itemId = $itemId;
 	}
 
-	/**
-	 * @return string
-	 */
 	public function getName() : string{
 		return $this->fallbackName ?? "Unknown";
 	}
 
-	/**
-	 * @return int
-	 */
 	final public function getId() : int{
 		return $this->id;
 	}
@@ -107,8 +94,6 @@ class Block extends Position implements BlockIds, Metadatable{
 	/**
 	 * 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).
-	 *
-	 * @return int
 	 */
 	public function getItemId() : int{
 		return $this->itemId ?? $this->getId();
@@ -116,22 +101,15 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * @internal
-	 * @return int
 	 */
 	public function getRuntimeId() : int{
 		return RuntimeBlockMapping::toStaticRuntimeId($this->getId(), $this->getDamage());
 	}
 
-	/**
-	 * @return int
-	 */
 	final public function getDamage() : int{
 		return $this->meta;
 	}
 
-	/**
-	 * @param int $meta
-	 */
 	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");
@@ -145,8 +123,6 @@ class Block extends Position implements BlockIds, Metadatable{
 	 *
 	 * If your block should not have any meta value when it's dropped as an item, override this to return 0 in
 	 * descendent classes.
-	 *
-	 * @return int
 	 */
 	public function getVariantBitmask() : int{
 		return -1;
@@ -154,24 +130,18 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns the block meta, stripped of non-variant flags.
-	 * @return int
 	 */
 	public function getVariant() : int{
 		return $this->meta & $this->getVariantBitmask();
 	}
 
-
 	/**
 	 * AKA: Block->isPlaceable
-	 * @return bool
 	 */
 	public function canBePlaced() : bool{
 		return true;
 	}
 
-	/**
-	 * @return bool
-	 */
 	public function canBeReplaced() : bool{
 		return false;
 	}
@@ -182,34 +152,18 @@ 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
-	 *
-	 * @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);
+		return $this->getLevelNonNull()->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{
 		return true;
 	}
 
-	/**
-	 * @return int
-	 */
 	public function getToolType() : int{
 		return BlockToolType::TYPE_NONE;
 	}
@@ -223,8 +177,6 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * Otherwise, 1 should be returned if a tool is required, 0 if not.
 	 *
 	 * @see Item::getBlockToolHarvestLevel()
-	 *
-	 * @return int
 	 */
 	public function getToolHarvestLevel() : int{
 		return 0;
@@ -236,10 +188,6 @@ class Block extends Position implements BlockIds, Metadatable{
 	 *
 	 * 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){
@@ -254,23 +202,14 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Do the actions needed so the block is broken with the Item
-	 *
-	 * @param Item        $item
-	 * @param Player|null $player
-	 *
-	 * @return bool
 	 */
 	public function onBreak(Item $item, Player $player = null) : bool{
-		return $this->getLevel()->setBlock($this, BlockFactory::get(Block::AIR), true, true);
+		return $this->getLevelNonNull()->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{
@@ -300,8 +239,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns whether random block updates will be done on this block.
-	 *
-	 * @return bool
 	 */
 	public function ticksRandomly() : bool{
 		return false;
@@ -324,11 +261,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Do actions when activated by Item. Returns if it has done anything
-	 *
-	 * @param Item        $item
-	 * @param Player|null $player
-	 *
-	 * @return bool
 	 */
 	public function onActivate(Item $item, Player $player = null) : bool{
 		return false;
@@ -336,7 +268,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns a base value used to compute block break times.
-	 * @return float
 	 */
 	public function getHardness() : float{
 		return 10;
@@ -344,15 +275,11 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns the block's resistance to explosions. Usually 5x hardness.
-	 * @return float
 	 */
 	public function getBlastResistance() : float{
 		return $this->getHardness() * 5;
 	}
 
-	/**
-	 * @return float
-	 */
 	public function getFrictionFactor() : float{
 		return 0.6;
 	}
@@ -380,16 +307,11 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * Examples of this behaviour include leaves and cobwebs.
 	 *
 	 * Light-diffusing blocks are included by the heightmap.
-	 *
-	 * @return bool
 	 */
 	public function diffusesSkyLight() : bool{
 		return false;
 	}
 
-	/**
-	 * @return bool
-	 */
 	public function isTransparent() : bool{
 		return false;
 	}
@@ -400,7 +322,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * AKA: Block->isFlowable
-	 * @return bool
 	 */
 	public function canBeFlowedInto() : bool{
 		return false;
@@ -416,21 +337,17 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns whether entities can climb up this block.
-	 * @return bool
 	 */
 	public function canClimb() : bool{
 		return false;
 	}
 
-
 	public function addVelocityToEntity(Entity $entity, Vector3 $vector) : void{
 
 	}
 
 	/**
 	 * Sets the block position to a new Position object
-	 *
-	 * @param Position $v
 	 */
 	final public function position(Position $v) : void{
 		$this->x = (int) $v->x;
@@ -443,8 +360,6 @@ class Block extends Position implements BlockIds, Metadatable{
 	/**
 	 * Returns an array of Item objects to be dropped
 	 *
-	 * @param Item $item
-	 *
 	 * @return Item[]
 	 */
 	public function getDrops(Item $item) : array{
@@ -462,8 +377,6 @@ class Block extends Position implements BlockIds, Metadatable{
 	/**
 	 * Returns an array of Items to be dropped when the block is broken using the correct tool type.
 	 *
-	 * @param Item $item
-	 *
 	 * @return Item[]
 	 */
 	public function getDropsForCompatibleTool(Item $item) : array{
@@ -475,8 +388,6 @@ class Block extends Position implements BlockIds, Metadatable{
 	/**
 	 * Returns an array of Items to be dropped when the block is broken using a compatible Silk Touch-enchanted tool.
 	 *
-	 * @param Item $item
-	 *
 	 * @return Item[]
 	 */
 	public function getSilkTouchDrops(Item $item) : array{
@@ -487,10 +398,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns how much XP will be dropped by breaking this block with the given item.
-	 *
-	 * @param Item $item
-	 *
-	 * @return int
 	 */
 	public function getXpDropForTool(Item $item) : int{
 		if($item->hasEnchantment(Enchantment::SILK_TOUCH) or !$this->isCompatibleWithTool($item)){
@@ -502,8 +409,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns how much XP this block will drop when broken with an appropriate tool.
-	 *
-	 * @return int
 	 */
 	protected function getXpDropAmount() : int{
 		return 0;
@@ -512,8 +417,6 @@ class Block extends Position implements BlockIds, Metadatable{
 	/**
 	 * Returns whether Silk Touch enchanted tools will cause this block to drop as itself. Since most blocks drop
 	 * themselves anyway, this is implicitly true.
-	 *
-	 * @return bool
 	 */
 	public function isAffectedBySilkTouch() : bool{
 		return true;
@@ -521,7 +424,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns the item that players will equip when middle-clicking on this block.
-	 * @return Item
 	 */
 	public function getPickedItem() : Item{
 		return ItemFactory::get($this->getItemId(), $this->getVariant());
@@ -529,7 +431,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns the time in ticks which the block will fuel a furnace for.
-	 * @return int
 	 */
 	public function getFuelTime() : int{
 		return 0;
@@ -538,8 +439,6 @@ class Block extends Position implements BlockIds, Metadatable{
 	/**
 	 * Returns the chance that the block will catch fire from nearby fire sources. Higher values lead to faster catching
 	 * fire.
-	 *
-	 * @return int
 	 */
 	public function getFlameEncouragement() : int{
 		return 0;
@@ -547,8 +446,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns the base flammability of this block. Higher values lead to the block burning away more quickly.
-	 *
-	 * @return int
 	 */
 	public function getFlammability() : int{
 		return 0;
@@ -556,8 +453,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns whether fire lit on this block will burn indefinitely.
-	 *
-	 * @return bool
 	 */
 	public function burnsForever() : bool{
 		return false;
@@ -565,8 +460,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Returns whether this block can catch fire.
-	 *
-	 * @return bool
 	 */
 	public function isFlammable() : bool{
 		return $this->getFlammability() > 0;
@@ -582,14 +475,11 @@ class Block extends Position implements BlockIds, Metadatable{
 	/**
 	 * Returns the Block on the side $side, works like Vector3::getSide()
 	 *
-	 * @param int $side
-	 * @param int $step
-	 *
 	 * @return Block
 	 */
 	public function getSide(int $side, int $step = 1){
 		if($this->isValid()){
-			return $this->getLevel()->getBlock(Vector3::getSide($side, $step));
+			return $this->getLevelNonNull()->getBlock(Vector3::getSide($side, $step));
 		}
 
 		return BlockFactory::get(Block::AIR, 0, Position::fromObject(Vector3::getSide($side, $step)));
@@ -643,10 +533,6 @@ class Block extends Position implements BlockIds, Metadatable{
 
 	/**
 	 * Checks for collision against an AxisAlignedBB
-	 *
-	 * @param AxisAlignedBB $bb
-	 *
-	 * @return bool
 	 */
 	public function collidesWithBB(AxisAlignedBB $bb) : bool{
 		foreach($this->getCollisionBoxes() as $bb2){
@@ -658,9 +544,6 @@ class Block extends Position implements BlockIds, Metadatable{
 		return false;
 	}
 
-	/**
-	 * @param Entity $entity
-	 */
 	public function onEntityCollide(Entity $entity) : void{
 
 	}
@@ -680,16 +563,13 @@ class Block extends Position implements BlockIds, Metadatable{
 	 * @return AxisAlignedBB[]
 	 */
 	protected function recalculateCollisionBoxes() : array{
-		if($bb = $this->recalculateBoundingBox()){
+		if(($bb = $this->recalculateBoundingBox()) !== null){
 			return [$bb];
 		}
 
 		return [];
 	}
 
-	/**
-	 * @return AxisAlignedBB|null
-	 */
 	public function getBoundingBox() : ?AxisAlignedBB{
 		if($this->boundingBox === null){
 			$this->boundingBox = $this->recalculateBoundingBox();
@@ -697,9 +577,6 @@ class Block extends Position implements BlockIds, Metadatable{
 		return $this->boundingBox;
 	}
 
-	/**
-	 * @return AxisAlignedBB|null
-	 */
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
 		return new AxisAlignedBB(
 			$this->x,
@@ -720,12 +597,6 @@ class Block extends Position implements BlockIds, Metadatable{
 		$this->collisionBoxes = null;
 	}
 
-	/**
-	 * @param Vector3 $pos1
-	 * @param Vector3 $pos2
-	 *
-	 * @return RayTraceResult|null
-	 */
 	public function calculateIntercept(Vector3 $pos1, Vector3 $pos2) : ?RayTraceResult{
 		$bbs = $this->getCollisionBoxes();
 		if(count($bbs) === 0){

src/pocketmine/block/BlockFactory.php

@@ -25,30 +25,54 @@ namespace pocketmine\block;
 
 use pocketmine\item\Item;
 use pocketmine\level\Position;
-use pocketmine\network\mcpe\protocol\types\RuntimeBlockMapping;
+use pocketmine\network\mcpe\convert\RuntimeBlockMapping;
 use function min;
 
 /**
  * Manages block registration and instance creation
  */
 class BlockFactory{
-	/** @var \SplFixedArray<Block> */
-	private static $fullList = null;
+	/**
+	 * @var \SplFixedArray|Block[]
+	 * @phpstan-var \SplFixedArray<Block>
+	 */
+	private static $fullList;
 
-	/** @var \SplFixedArray<bool> */
-	public static $solid = null;
-	/** @var \SplFixedArray<bool> */
-	public static $transparent = null;
-	/** @var \SplFixedArray<float> */
-	public static $hardness = null;
-	/** @var \SplFixedArray<int> */
-	public static $light = null;
-	/** @var \SplFixedArray<int> */
-	public static $lightFilter = null;
-	/** @var \SplFixedArray<bool> */
-	public static $diffusesSkyLight = null;
-	/** @var \SplFixedArray<float> */
-	public static $blastResistance = null;
+	/**
+	 * @var \SplFixedArray|bool[]
+	 * @phpstan-var \SplFixedArray<bool>
+	 */
+	public static $solid;
+	/**
+	 * @var \SplFixedArray|bool[]
+	 * @phpstan-var \SplFixedArray<bool>
+	 */
+	public static $transparent;
+	/**
+	 * @var \SplFixedArray|float[]
+	 * @phpstan-var \SplFixedArray<float>
+	 */
+	public static $hardness;
+	/**
+	 * @var \SplFixedArray|int[]
+	 * @phpstan-var \SplFixedArray<int>
+	 */
+	public static $light;
+	/**
+	 * @var \SplFixedArray|int[]
+	 * @phpstan-var \SplFixedArray<int>
+	 */
+	public static $lightFilter;
+	/**
+	 * @var \SplFixedArray|bool[]
+	 * @phpstan-var \SplFixedArray<bool>
+	 */
+	public static $diffusesSkyLight;
+	/**
+	 * @var \SplFixedArray|float[]
+	 * @phpstan-var \SplFixedArray<float>
+	 */
+	public static $blastResistance;
 
 	/**
 	 * Initializes the block factory. By default this is called only once on server start, however you may wish to use
@@ -334,7 +358,6 @@ class BlockFactory{
 	 * NOTE: If you are registering a new block type, you will need to add it to the creative inventory yourself - it
 	 * will not automatically appear there.
 	 *
-	 * @param Block $block
 	 * @param bool  $override Whether to override existing registrations
 	 *
 	 * @throws \RuntimeException if something attempted to override an already-registered block without specifying the
@@ -364,12 +387,6 @@ class BlockFactory{
 
 	/**
 	 * Returns a new Block instance with the specified ID, meta and position.
-	 *
-	 * @param int      $id
-	 * @param int      $meta
-	 * @param Position $pos
-	 *
-	 * @return Block
 	 */
 	public static function get(int $id, int $meta = 0, Position $pos = null) : Block{
 		if($meta < 0 or $meta > 0xf){
@@ -398,7 +415,7 @@ class BlockFactory{
 
 	/**
 	 * @internal
-	 * @return \SplFixedArray
+	 * @phpstan-return \SplFixedArray<Block>
 	 */
 	public static function getBlockStatesArray() : \SplFixedArray{
 		return self::$fullList;
@@ -406,10 +423,6 @@ class BlockFactory{
 
 	/**
 	 * Returns whether a specified block ID is already registered in the block factory.
-	 *
-	 * @param int $id
-	 *
-	 * @return bool
 	 */
 	public static function isRegistered(int $id) : bool{
 		$b = self::$fullList[$id << 4];
@@ -419,11 +432,6 @@ class BlockFactory{
 	/**
 	 * @internal
 	 * @deprecated
-	 *
-	 * @param int $id
-	 * @param int $meta
-	 *
-	 * @return int
 	 */
 	public static function toStaticRuntimeId(int $id, int $meta = 0) : int{
 		return RuntimeBlockMapping::toStaticRuntimeId($id, $meta);
@@ -433,8 +441,6 @@ class BlockFactory{
 	 * @deprecated
 	 * @internal
 	 *
-	 * @param int $runtimeId
-	 *
 	 * @return int[] [id, meta]
 	 */
 	public static function fromStaticRuntimeId(int $runtimeId) : array{

src/pocketmine/block/BlockToolType.php

@@ -35,5 +35,6 @@ interface BlockToolType{
 	public const TYPE_PICKAXE = 1 << 2;
 	public const TYPE_AXE = 1 << 3;
 	public const TYPE_SHEARS = 1 << 4;
+	public const TYPE_HOE = 1 << 5;
 
 }

src/pocketmine/block/BoneBlock.php

@@ -55,7 +55,7 @@ class BoneBlock extends Solid{
 
 	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);
+		return $this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 	}
 
 	public function getVariantBitmask() : int{

src/pocketmine/block/BurningFurnace.php

@@ -68,18 +68,18 @@ class BurningFurnace extends Solid{
 			3 => 3
 		];
 		$this->meta = $faces[$player instanceof Player ? $player->getDirection() : 0];
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
+		$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
-		Tile::createTile(Tile::FURNACE, $this->getLevel(), TileFurnace::createNBT($this, $face, $item, $player));
+		Tile::createTile(Tile::FURNACE, $this->getLevelNonNull(), 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);
+			$furnace = $this->getLevelNonNull()->getTile($this);
 			if(!($furnace instanceof TileFurnace)){
-				$furnace = Tile::createTile(Tile::FURNACE, $this->getLevel(), TileFurnace::createNBT($this));
+				$furnace = Tile::createTile(Tile::FURNACE, $this->getLevelNonNull(), TileFurnace::createNBT($this));
 				if(!($furnace instanceof TileFurnace)){
 					return true;
 				}

src/pocketmine/block/Cactus.php

@@ -72,12 +72,12 @@ class Cactus extends Transparent{
 	public function onNearbyBlockChange() : void{
 		$down = $this->getSide(Vector3::SIDE_DOWN);
 		if($down->getId() !== self::SAND and $down->getId() !== self::CACTUS){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}else{
 			for($side = 2; $side <= 5; ++$side){
 				$b = $this->getSide($side);
 				if($b->isSolid()){
-					$this->getLevel()->useBreakOn($this);
+					$this->getLevelNonNull()->useBreakOn($this);
 					break;
 				}
 			}
@@ -92,23 +92,23 @@ class Cactus extends Transparent{
 		if($this->getSide(Vector3::SIDE_DOWN)->getId() !== self::CACTUS){
 			if($this->meta === 0x0f){
 				for($y = 1; $y < 3; ++$y){
-					$b = $this->getLevel()->getBlockAt($this->x, $this->y + $y, $this->z);
+					$b = $this->getLevelNonNull()->getBlockAt($this->x, $this->y + $y, $this->z);
 					if($b->getId() === self::AIR){
 						$ev = new BlockGrowEvent($b, BlockFactory::get(Block::CACTUS));
 						$ev->call();
 						if($ev->isCancelled()){
 							break;
 						}
-						$this->getLevel()->setBlock($b, $ev->getNewState(), true);
+						$this->getLevelNonNull()->setBlock($b, $ev->getNewState(), true);
 					}else{
 						break;
 					}
 				}
 				$this->meta = 0;
-				$this->getLevel()->setBlock($this, $this);
+				$this->getLevelNonNull()->setBlock($this, $this);
 			}else{
 				++$this->meta;
-				$this->getLevel()->setBlock($this, $this);
+				$this->getLevelNonNull()->setBlock($this, $this);
 			}
 		}
 	}
@@ -121,7 +121,7 @@ class Cactus extends Transparent{
 			$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);
+				$this->getLevelNonNull()->setBlock($this, $this, true);
 
 				return true;
 			}

src/pocketmine/block/Cake.php

@@ -66,7 +66,7 @@ class Cake extends Transparent implements FoodSource{
 	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);
+			$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
 			return true;
 		}
@@ -76,7 +76,7 @@ class Cake extends Transparent implements FoodSource{
 
 	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);
+			$this->getLevelNonNull()->setBlock($this, BlockFactory::get(Block::AIR), true);
 		}
 	}
 
@@ -109,6 +109,10 @@ class Cake extends Transparent implements FoodSource{
 		return true;
 	}
 
+	public function getVariantBitmask() : int{
+		return 0;
+	}
+
 	/**
 	 * @return Block
 	 */

src/pocketmine/block/Carpet.php

@@ -64,7 +64,7 @@ class Carpet extends Flowable{
 	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);
+			$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
 			return true;
 		}
@@ -74,7 +74,7 @@ class Carpet extends Flowable{
 
 	public function onNearbyBlockChange() : void{
 		if($this->getSide(Vector3::SIDE_DOWN)->getId() === self::AIR){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}
 	}
 

src/pocketmine/block/Chest.php

@@ -81,7 +81,7 @@ class Chest extends Transparent{
 			}
 			$c = $this->getSide($side);
 			if($c->getId() === $this->id and $c->getDamage() === $this->meta){
-				$tile = $this->getLevel()->getTile($c);
+				$tile = $this->getLevelNonNull()->getTile($c);
 				if($tile instanceof TileChest and !$tile->isPaired()){
 					$chest = $tile;
 					break;
@@ -89,8 +89,8 @@ class Chest extends Transparent{
 			}
 		}
 
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
-		$tile = Tile::createTile(Tile::CHEST, $this->getLevel(), TileChest::createNBT($this, $face, $item, $player));
+		$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
+		$tile = Tile::createTile(Tile::CHEST, $this->getLevelNonNull(), TileChest::createNBT($this, $face, $item, $player));
 
 		if($chest instanceof TileChest and $tile instanceof TileChest){
 			$chest->pairWith($tile);
@@ -103,12 +103,12 @@ class Chest extends Transparent{
 	public function onActivate(Item $item, Player $player = null) : bool{
 		if($player instanceof Player){
 
-			$t = $this->getLevel()->getTile($this);
+			$t = $this->getLevelNonNull()->getTile($this);
 			$chest = null;
 			if($t instanceof TileChest){
 				$chest = $t;
 			}else{
-				$chest = Tile::createTile(Tile::CHEST, $this->getLevel(), TileChest::createNBT($this));
+				$chest = Tile::createTile(Tile::CHEST, $this->getLevelNonNull(), TileChest::createNBT($this));
 				if(!($chest instanceof TileChest)){
 					return true;
 				}
@@ -116,7 +116,7 @@ class Chest extends Transparent{
 
 			if(
 				!$this->getSide(Vector3::SIDE_UP)->isTransparent() or
-				($chest->isPaired() and !$chest->getPair()->getBlock()->getSide(Vector3::SIDE_UP)->isTransparent()) or
+				(($pair = $chest->getPair()) !== null and !$pair->getBlock()->getSide(Vector3::SIDE_UP)->isTransparent()) or
 				!$chest->canOpenWith($item->getCustomName())
 			){
 				return true;

src/pocketmine/block/CobblestoneWall.php

@@ -112,8 +112,6 @@ class CobblestoneWall extends Transparent{
 	}
 
 	/**
-	 * @param Block $block
-	 *
 	 * @return bool
 	 */
 	public function canConnect(Block $block){

src/pocketmine/block/CocoaBlock.php

@@ -23,6 +23,11 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
+use pocketmine\item\Item;
+use pocketmine\item\ItemFactory;
+use pocketmine\item\ItemIds;
+use function mt_rand;
+
 class CocoaBlock extends Transparent{
 
 	protected $id = self::COCOA_BLOCK;
@@ -48,4 +53,14 @@ class CocoaBlock extends Transparent{
 	public function isAffectedBySilkTouch() : bool{
 		return false;
 	}
+
+	public function getDropsForCompatibleTool(Item $item) : array{
+		return [
+			ItemFactory::get(ItemIds::DYE, 3, ($this->meta >> 2) === 2 ? mt_rand(2, 3) : 1)
+		];
+	}
+
+	public function getPickedItem() : Item{
+		return ItemFactory::get(ItemIds::DYE, 3);
+	}
 }

src/pocketmine/block/ConcretePowder.php

@@ -53,16 +53,10 @@ class ConcretePowder extends Fallable{
 		}
 	}
 
-	/**
-	 * @return null|Block
-	 */
 	public function tickFalling() : ?Block{
 		return $this->checkAdjacentWater();
 	}
 
-	/**
-	 * @return null|Block
-	 */
 	private function checkAdjacentWater() : ?Block{
 		for($i = 1; $i < 6; ++$i){ //Do not check underneath
 			if($this->getSide($i) instanceof Water){

src/pocketmine/block/CraftingTable.php

@@ -25,7 +25,10 @@ namespace pocketmine\block;
 
 use pocketmine\inventory\CraftingGrid;
 use pocketmine\item\Item;
+use pocketmine\network\mcpe\protocol\ContainerOpenPacket;
+use pocketmine\network\mcpe\protocol\types\WindowTypes;
 use pocketmine\Player;
+use function array_key_exists;
 
 class CraftingTable extends Solid{
 
@@ -50,6 +53,19 @@ class CraftingTable extends Solid{
 	public function onActivate(Item $item, Player $player = null) : bool{
 		if($player instanceof Player){
 			$player->setCraftingGrid(new CraftingGrid($player, CraftingGrid::SIZE_BIG));
+
+			if(!array_key_exists($windowId = Player::HARDCODED_CRAFTING_GRID_WINDOW_ID, $player->openHardcodedWindows)){
+				//TODO: HACK! crafting grid doesn't fit very well into the current PM container system, so this hack allows
+				//it to carry on working approximately the same way as it did in 1.14
+				$pk = new ContainerOpenPacket();
+				$pk->windowId = $windowId;
+				$pk->type = WindowTypes::WORKBENCH;
+				$pk->x = $this->getFloorX();
+				$pk->y = $this->getFloorY();
+				$pk->z = $this->getFloorZ();
+				$player->sendDataPacket($pk);
+				$player->openHardcodedWindows[$windowId] = true;
+			}
 		}
 
 		return true;

src/pocketmine/block/Crops.php

@@ -33,7 +33,7 @@ abstract class Crops extends Flowable{
 
 	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);
+			$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
 			return true;
 		}
@@ -41,7 +41,6 @@ abstract class Crops extends Flowable{
 		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
 			$block = clone $this;
@@ -53,10 +52,10 @@ abstract class Crops extends Flowable{
 			$ev = new BlockGrowEvent($this, $block);
 			$ev->call();
 			if(!$ev->isCancelled()){
-				$this->getLevel()->setBlock($this, $ev->getNewState(), true, true);
+				$this->getLevelNonNull()->setBlock($this, $ev->getNewState(), true, true);
 			}
 
-			$item->count--;
+			$item->pop();
 
 			return true;
 		}
@@ -66,7 +65,7 @@ abstract class Crops extends Flowable{
 
 	public function onNearbyBlockChange() : void{
 		if($this->getSide(Vector3::SIDE_DOWN)->getId() !== Block::FARMLAND){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}
 	}
 
@@ -82,7 +81,7 @@ abstract class Crops extends Flowable{
 				$ev = new BlockGrowEvent($this, $block);
 				$ev->call();
 				if(!$ev->isCancelled()){
-					$this->getLevel()->setBlock($this, $ev->getNewState(), true, true);
+					$this->getLevelNonNull()->setBlock($this, $ev->getNewState(), true, true);
 				}
 			}
 		}

src/pocketmine/block/Dandelion.php

@@ -39,11 +39,10 @@ class Dandelion extends Flowable{
 		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);
+			$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
 			return true;
 		}
@@ -53,7 +52,7 @@ class Dandelion extends Flowable{
 
 	public function onNearbyBlockChange() : void{
 		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}
 	}
 

src/pocketmine/block/DeadBush.php

@@ -51,7 +51,7 @@ class DeadBush extends Flowable{
 
 	public function onNearbyBlockChange() : void{
 		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}
 	}
 

src/pocketmine/block/Dirt.php

@@ -54,9 +54,9 @@ class Dirt extends Solid{
 		if($item instanceof Hoe){
 			$item->applyDamage(1);
 			if($this->meta === 1){
-				$this->getLevel()->setBlock($this, BlockFactory::get(Block::DIRT), true);
+				$this->getLevelNonNull()->setBlock($this, BlockFactory::get(Block::DIRT), true);
 			}else{
-				$this->getLevel()->setBlock($this, BlockFactory::get(Block::FARMLAND), true);
+				$this->getLevelNonNull()->setBlock($this, BlockFactory::get(Block::FARMLAND), true);
 			}
 
 			return true;

src/pocketmine/block/Door.php

@@ -29,7 +29,6 @@ use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Vector3;
 use pocketmine\Player;
 
-
 abstract class Door extends Transparent{
 
 	public function isSolid() : bool{
@@ -202,9 +201,9 @@ abstract class Door extends Transparent{
 
 	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);
+			$this->getLevelNonNull()->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);
+				$this->getLevelNonNull()->setBlock($this->getSide(Vector3::SIDE_UP), BlockFactory::get(Block::AIR), false);
 			}
 		}
 	}
@@ -231,8 +230,8 @@ abstract class Door extends Transparent{
 			}
 
 			$this->setDamage($player->getDirection() & 0x03);
-			$this->getLevel()->setBlock($blockReplace, $this, true, true); //Bottom
-			$this->getLevel()->setBlock($blockUp, BlockFactory::get($this->getId(), $metaUp), true); //Top
+			$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true); //Bottom
+			$this->getLevelNonNull()->setBlock($blockUp, BlockFactory::get($this->getId(), $metaUp), true); //Top
 			return true;
 		}
 

src/pocketmine/block/DoublePlant.php

@@ -57,8 +57,8 @@ class DoublePlant extends Flowable{
 	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);
+			$this->getLevelNonNull()->setBlock($blockReplace, $this, false, false);
+			$this->getLevelNonNull()->setBlock($blockReplace->getSide(Vector3::SIDE_UP), BlockFactory::get($this->id, $this->meta | self::BITFLAG_TOP), false, false);
 
 			return true;
 		}
@@ -68,10 +68,9 @@ class DoublePlant extends Flowable{
 
 	/**
 	 * Returns whether this double-plant has a corresponding other half.
-	 * @return bool
 	 */
 	public function isValidHalfPlant() : bool{
-		if($this->meta & self::BITFLAG_TOP){
+		if(($this->meta & self::BITFLAG_TOP) !== 0){
 			$other = $this->getSide(Vector3::SIDE_DOWN);
 		}else{
 			$other = $this->getSide(Vector3::SIDE_UP);
@@ -86,7 +85,7 @@ class DoublePlant extends Flowable{
 
 	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);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}
 	}
 
@@ -103,7 +102,7 @@ class DoublePlant extends Flowable{
 	}
 
 	public function getDrops(Item $item) : array{
-		if($this->meta & self::BITFLAG_TOP){
+		if(($this->meta & self::BITFLAG_TOP) !== 0){
 			if($this->isCompatibleWithTool($item)){
 				return parent::getDrops($item);
 			}
@@ -125,4 +124,12 @@ class DoublePlant extends Flowable{
 
 		return parent::getAffectedBlocks();
 	}
+
+	public function getFlameEncouragement() : int{
+		return 60;
+	}
+
+	public function getFlammability() : int{
+		return 100;
+	}
 }

src/pocketmine/block/EnchantingTable.php

@@ -40,9 +40,9 @@ class EnchantingTable extends Transparent{
 	}
 
 	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
+		$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
-		Tile::createTile(Tile::ENCHANT_TABLE, $this->getLevel(), TileEnchantTable::createNBT($this, $face, $item, $player));
+		Tile::createTile(Tile::ENCHANT_TABLE, $this->getLevelNonNull(), TileEnchantTable::createNBT($this, $face, $item, $player));
 
 		return true;
 	}

src/pocketmine/block/EnderChest.php

@@ -69,8 +69,8 @@ class EnderChest extends Chest{
 
 		$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));
+		$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
+		Tile::createTile(Tile::ENDER_CHEST, $this->getLevelNonNull(), TileEnderChest::createNBT($this, $face, $item, $player));
 
 		return true;
 	}
@@ -78,12 +78,12 @@ class EnderChest extends Chest{
 	public function onActivate(Item $item, Player $player = null) : bool{
 		if($player instanceof Player){
 
-			$t = $this->getLevel()->getTile($this);
+			$t = $this->getLevelNonNull()->getTile($this);
 			$enderChest = null;
 			if($t instanceof TileEnderChest){
 				$enderChest = $t;
 			}else{
-				$enderChest = Tile::createTile(Tile::ENDER_CHEST, $this->getLevel(), TileEnderChest::createNBT($this));
+				$enderChest = Tile::createTile(Tile::ENDER_CHEST, $this->getLevelNonNull(), TileEnderChest::createNBT($this));
 				if(!($enderChest instanceof TileEnderChest)){
 					return true;
 				}

src/pocketmine/block/Fallable.php

@@ -37,7 +37,7 @@ abstract class Fallable extends Solid{
 			$nbt->setInt("TileID", $this->getId());
 			$nbt->setByte("Data", $this->getDamage());
 
-			$fall = Entity::createEntity("FallingSand", $this->getLevel(), $nbt);
+			$fall = Entity::createEntity("FallingSand", $this->getLevelNonNull(), $nbt);
 
 			if($fall !== null){
 				$fall->spawnToAll();
@@ -45,9 +45,6 @@ abstract class Fallable extends Solid{
 		}
 	}
 
-	/**
-	 * @return null|Block
-	 */
 	public function tickFalling() : ?Block{
 		return null;
 	}

src/pocketmine/block/Farmland.php

@@ -48,7 +48,6 @@ class Farmland extends Transparent{
 		return BlockToolType::TYPE_SHOVEL;
 	}
 
-
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
 		return new AxisAlignedBB(
 			$this->x,

src/pocketmine/block/Fence.php

@@ -104,8 +104,6 @@ abstract class Fence extends Transparent{
 	}
 
 	/**
-	 * @param Block $block
-	 *
 	 * @return bool
 	 */
 	public function canConnect(Block $block){

src/pocketmine/block/FenceGate.php

@@ -39,7 +39,6 @@ class FenceGate extends Transparent{
 		return BlockToolType::TYPE_AXE;
 	}
 
-
 	protected function recalculateBoundingBox() : ?AxisAlignedBB{
 
 		if(($this->getDamage() & 0x04) > 0){
@@ -70,7 +69,7 @@ class FenceGate extends Transparent{
 
 	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);
+		$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
 		return true;
 	}
@@ -86,7 +85,7 @@ class FenceGate extends Transparent{
 			$this->meta |= (($player->getDirection() - 1) & 0x02);
 		}
 
-		$this->getLevel()->setBlock($this, $this, true);
+		$this->getLevelNonNull()->setBlock($this, $this, true);
 		$this->level->addSound(new DoorSound($this));
 		return true;
 	}

src/pocketmine/block/Fire.php

@@ -82,7 +82,7 @@ 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);
+			$this->getLevelNonNull()->setBlock($this, BlockFactory::get(Block::AIR), true);
 		}else{
 			$this->level->scheduleDelayedBlockUpdate($this, mt_rand(30, 40));
 		}

src/pocketmine/block/Flower.php

@@ -62,7 +62,7 @@ class Flower extends Flowable{
 	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);
+			$this->getLevelNonNull()->setBlock($blockReplace, $this, true);
 
 			return true;
 		}
@@ -72,7 +72,7 @@ class Flower extends Flowable{
 
 	public function onNearbyBlockChange() : void{
 		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}
 	}
 

src/pocketmine/block/FlowerPot.php

@@ -62,19 +62,19 @@ class FlowerPot extends Flowable{
 			return false;
 		}
 
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
-		Tile::createTile(Tile::FLOWER_POT, $this->getLevel(), TileFlowerPot::createNBT($this, $face, $item, $player));
+		$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
+		Tile::createTile(Tile::FLOWER_POT, $this->getLevelNonNull(), TileFlowerPot::createNBT($this, $face, $item, $player));
 		return true;
 	}
 
 	public function onNearbyBlockChange() : void{
 		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}
 	}
 
 	public function onActivate(Item $item, Player $player = null) : bool{
-		$pot = $this->getLevel()->getTile($this);
+		$pot = $this->getLevelNonNull()->getTile($this);
 		if(!($pot instanceof TileFlowerPot)){
 			return false;
 		}
@@ -83,7 +83,7 @@ class FlowerPot extends Flowable{
 		}
 
 		$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);
+		$this->getLevelNonNull()->setBlock($this, $this, true, false);
 		$pot->setItem($item->pop());
 
 		return true;
@@ -96,7 +96,7 @@ class FlowerPot extends Flowable{
 	public function getDropsForCompatibleTool(Item $item) : array{
 		$items = parent::getDropsForCompatibleTool($item);
 
-		$tile = $this->getLevel()->getTile($this);
+		$tile = $this->getLevelNonNull()->getTile($this);
 		if($tile instanceof TileFlowerPot){
 			$item = $tile->getItem();
 			if($item->getId() !== Item::AIR){

src/pocketmine/block/Furnace.php

@@ -23,7 +23,6 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-
 class Furnace extends BurningFurnace{
 
 	protected $id = self::FURNACE;

src/pocketmine/block/GlazedTerracotta.php

@@ -1,6 +1,5 @@
 <?php
 
-
 /*
  *
  *  ____            _        _   __  __ _                  __  __ ____
@@ -54,7 +53,7 @@ class GlazedTerracotta extends Solid{
 			$this->meta = $faces[(~($player->getDirection() - 1)) & 0x03];
 		}
 
-		return $this->getLevel()->setBlock($blockReplace, $this, true, true);
+		return $this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 	}
 
 	public function getVariantBitmask() : int{

src/pocketmine/block/GlowingObsidian.php

@@ -23,7 +23,6 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-
 use pocketmine\item\TieredTool;
 
 class GlowingObsidian extends Solid{

src/pocketmine/block/GlowingRedstoneOre.php

@@ -53,6 +53,6 @@ class GlowingRedstoneOre extends RedstoneOre{
 	}
 
 	public function onRandomTick() : void{
-		$this->getLevel()->setBlock($this, BlockFactory::get(Block::REDSTONE_ORE, $this->meta), false, false);
+		$this->getLevelNonNull()->setBlock($this, BlockFactory::get(Block::REDSTONE_ORE, $this->meta), false, false);
 	}
 }

src/pocketmine/block/Grass.php

@@ -99,18 +99,18 @@ class Grass extends Solid{
 
 	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);
+			$item->pop();
+			TallGrassObject::growGrass($this->getLevelNonNull(), $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->getLevelNonNull()->setBlock($this, BlockFactory::get(Block::FARMLAND));
 
 			return true;
 		}elseif($item instanceof Shovel and $this->getSide(Vector3::SIDE_UP)->getId() === Block::AIR){
 			$item->applyDamage(1);
-			$this->getLevel()->setBlock($this, BlockFactory::get(Block::GRASS_PATH));
+			$this->getLevelNonNull()->setBlock($this, BlockFactory::get(Block::GRASS_PATH));
 
 			return true;
 		}

src/pocketmine/block/HayBale.php

@@ -46,7 +46,7 @@ class HayBale extends Solid{
 
 	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
 		$this->meta = PillarRotationHelper::getMetaFromFace($this->meta, $face);
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
+		$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
 		return true;
 	}

src/pocketmine/block/Ice.php

@@ -57,7 +57,7 @@ class Ice extends Transparent{
 
 	public function onBreak(Item $item, Player $player = null) : bool{
 		if(($player === null or $player->isSurvival()) and !$item->hasEnchantment(Enchantment::SILK_TOUCH)){
-			return $this->getLevel()->setBlock($this, BlockFactory::get(Block::WATER), true);
+			return $this->getLevelNonNull()->setBlock($this, BlockFactory::get(Block::WATER), true);
 		}
 		return parent::onBreak($item, $player);
 	}

src/pocketmine/block/ItemFrame.php

@@ -46,7 +46,7 @@ class ItemFrame extends Flowable{
 	public function onActivate(Item $item, Player $player = null) : bool{
 		$tile = $this->level->getTile($this);
 		if(!($tile instanceof TileItemFrame)){
-			$tile = Tile::createTile(Tile::ITEM_FRAME, $this->getLevel(), TileItemFrame::createNBT($this));
+			$tile = Tile::createTile(Tile::ITEM_FRAME, $this->getLevelNonNull(), TileItemFrame::createNBT($this));
 			if(!($tile instanceof TileItemFrame)){
 				return true;
 			}
@@ -88,7 +88,7 @@ class ItemFrame extends Flowable{
 		$this->meta = $faces[$face];
 		$this->level->setBlock($blockReplace, $this, true, true);
 
-		Tile::createTile(Tile::ITEM_FRAME, $this->getLevel(), TileItemFrame::createNBT($this, $face, $item, $player));
+		Tile::createTile(Tile::ITEM_FRAME, $this->getLevelNonNull(), TileItemFrame::createNBT($this, $face, $item, $player));
 
 		return true;
 

src/pocketmine/block/Ladder.php

@@ -24,6 +24,7 @@ declare(strict_types=1);
 namespace pocketmine\block;
 
 use pocketmine\entity\Entity;
+use pocketmine\entity\Living;
 use pocketmine\item\Item;
 use pocketmine\math\AxisAlignedBB;
 use pocketmine\math\Vector3;
@@ -58,7 +59,7 @@ class Ladder extends Transparent{
 	}
 
 	public function onEntityCollide(Entity $entity) : void{
-		if($entity->asVector3()->floor()->distanceSquared($this) < 1){ //entity coordinates must be inside block
+		if($entity instanceof Living and $entity->asVector3()->floor()->distanceSquared($this) < 1){ //entity coordinates must be inside block
 			$entity->resetFallDistance();
 			$entity->onGround = true;
 		}
@@ -90,7 +91,6 @@ class Ladder extends Transparent{
 		);
 	}
 
-
 	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
 		if(!$blockClicked->isTransparent()){
 			$faces = [
@@ -101,7 +101,7 @@ class Ladder extends Transparent{
 			];
 			if(isset($faces[$face])){
 				$this->meta = $faces[$face];
-				$this->getLevel()->setBlock($blockReplace, $this, true, true);
+				$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
 				return true;
 			}

src/pocketmine/block/Lava.php

@@ -115,8 +115,8 @@ class Lava extends Liquid{
 	}
 
 	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		$ret = $this->getLevel()->setBlock($this, $this, true, false);
-		$this->getLevel()->scheduleDelayedBlockUpdate($this, $this->tickRate());
+		$ret = $this->getLevelNonNull()->setBlock($this, $this, true, false);
+		$this->getLevelNonNull()->scheduleDelayedBlockUpdate($this, $this->tickRate());
 
 		return $ret;
 	}

src/pocketmine/block/Leaves.php

@@ -68,7 +68,10 @@ class Leaves extends Transparent{
 		return true;
 	}
 
-
+	/**
+	 * @param true[] $visited reference parameter
+	 * @phpstan-param array<string, true> $visited
+	 */
 	protected function findLog(Block $pos, array &$visited, int $distance, ?int $fromSide = null) : bool{
 		$index = $pos->x . "." . $pos->y . "." . $pos->z;
 		if(isset($visited[$index])){
@@ -136,7 +139,7 @@ class Leaves extends Transparent{
 	public function onNearbyBlockChange() : void{
 		if(($this->meta & 0b00001100) === 0){
 			$this->meta |= 0x08;
-			$this->getLevel()->setBlock($this, $this, true, false);
+			$this->getLevelNonNull()->setBlock($this, $this, true, false);
 		}
 	}
 
@@ -152,16 +155,16 @@ class Leaves extends Transparent{
 			$ev = new LeavesDecayEvent($this);
 			$ev->call();
 			if($ev->isCancelled() or $this->findLog($this, $visited, 0)){
-				$this->getLevel()->setBlock($this, $this, false, false);
+				$this->getLevelNonNull()->setBlock($this, $this, false, false);
 			}else{
-				$this->getLevel()->useBreakOn($this);
+				$this->getLevelNonNull()->useBreakOn($this);
 			}
 		}
 	}
 
 	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
 		$this->meta |= 0x04;
-		return $this->getLevel()->setBlock($this, $this, true);
+		return $this->getLevelNonNull()->setBlock($this, $this, true);
 	}
 
 	public function getVariantBitmask() : int{
@@ -169,7 +172,7 @@ class Leaves extends Transparent{
 	}
 
 	public function getDrops(Item $item) : array{
-		if($item->getBlockToolType() & BlockToolType::TYPE_SHEARS){
+		if(($item->getBlockToolType() & BlockToolType::TYPE_SHEARS) !== 0){
 			return $this->getDropsForCompatibleTool($item);
 		}
 

src/pocketmine/block/Liquid.php

@@ -211,8 +211,6 @@ abstract class Liquid extends Transparent{
 
 	/**
 	 * Returns how many liquid levels are lost per block flowed horizontally. Affects how far the liquid can flow.
-	 *
-	 * @return int
 	 */
 	public function getFlowDecayPerBlock() : int{
 		return 1;

src/pocketmine/block/MelonStem.php

@@ -49,7 +49,7 @@ class MelonStem extends Crops{
 				$ev = new BlockGrowEvent($this, $block);
 				$ev->call();
 				if(!$ev->isCancelled()){
-					$this->getLevel()->setBlock($this, $ev->getNewState(), true);
+					$this->getLevelNonNull()->setBlock($this, $ev->getNewState(), true);
 				}
 			}else{
 				for($side = 2; $side <= 5; ++$side){
@@ -64,7 +64,7 @@ class MelonStem extends Crops{
 					$ev = new BlockGrowEvent($side, BlockFactory::get(Block::MELON_BLOCK));
 					$ev->call();
 					if(!$ev->isCancelled()){
-						$this->getLevel()->setBlock($side, $ev->getNewState(), true);
+						$this->getLevelNonNull()->setBlock($side, $ev->getNewState(), true);
 					}
 				}
 			}

src/pocketmine/block/MossyCobblestone.php

@@ -23,7 +23,6 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-
 class MossyCobblestone extends Cobblestone{
 
 	protected $id = self::MOSSY_COBBLESTONE;

src/pocketmine/block/Mycelium.php

@@ -64,13 +64,13 @@ class Mycelium extends Solid{
 		$x = mt_rand($this->x - 1, $this->x + 1);
 		$y = mt_rand($this->y - 2, $this->y + 2);
 		$z = mt_rand($this->z - 1, $this->z + 1);
-		$block = $this->getLevel()->getBlockAt($x, $y, $z);
+		$block = $this->getLevelNonNull()->getBlockAt($x, $y, $z);
 		if($block->getId() === Block::DIRT){
 			if($block->getSide(Vector3::SIDE_UP) instanceof Transparent){
 				$ev = new BlockSpreadEvent($block, $this, BlockFactory::get(Block::MYCELIUM));
 				$ev->call();
 				if(!$ev->isCancelled()){
-					$this->getLevel()->setBlock($block, $ev->getNewState());
+					$this->getLevelNonNull()->setBlock($block, $ev->getNewState());
 				}
 			}
 		}

src/pocketmine/block/NetherWartPlant.php

@@ -23,7 +23,6 @@ declare(strict_types=1);
 
 namespace pocketmine\block;
 
-
 use pocketmine\event\block\BlockGrowEvent;
 use pocketmine\item\Item;
 use pocketmine\item\ItemFactory;
@@ -47,7 +46,7 @@ class NetherWartPlant extends Flowable{
 	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::SOUL_SAND){
-			$this->getLevel()->setBlock($blockReplace, $this, false, true);
+			$this->getLevelNonNull()->setBlock($blockReplace, $this, false, true);
 
 			return true;
 		}
@@ -57,7 +56,7 @@ class NetherWartPlant extends Flowable{
 
 	public function onNearbyBlockChange() : void{
 		if($this->getSide(Vector3::SIDE_DOWN)->getId() !== Block::SOUL_SAND){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}
 	}
 
@@ -72,7 +71,7 @@ class NetherWartPlant extends Flowable{
 			$ev = new BlockGrowEvent($this, $block);
 			$ev->call();
 			if(!$ev->isCancelled()){
-				$this->getLevel()->setBlock($this, $ev->getNewState(), false, true);
+				$this->getLevelNonNull()->setBlock($this, $ev->getNewState(), false, true);
 			}
 		}
 	}

src/pocketmine/block/Podzol.php

@@ -40,6 +40,6 @@ class Podzol extends Solid{
 	}
 
 	public function getHardness() : float{
-		return 2.5;
+		return 0.5;
 	}
 }

src/pocketmine/block/Potato.php

@@ -40,9 +40,13 @@ class Potato extends Crops{
 	}
 
 	public function getDropsForCompatibleTool(Item $item) : array{
-		return [
-			ItemFactory::get(Item::POTATO, 0, $this->getDamage() >= 0x07 ? mt_rand(1, 4) : 1)
+		$result = [
+			ItemFactory::get(Item::POTATO, 0, $this->getDamage() >= 0x07 ? mt_rand(1, 5) : 1)
 		];
+		if($this->getDamage() >= 7 && mt_rand(0, 49) === 0){
+			$result[] = ItemFactory::get(Item::POISONOUS_POTATO);
+		}
+		return $result;
 	}
 
 	public function getPickedItem() : Item{

src/pocketmine/block/Pumpkin.php

@@ -51,7 +51,7 @@ class Pumpkin extends Solid{
 		if($player instanceof Player){
 			$this->meta = ((int) $player->getDirection() + 1) % 4;
 		}
-		$this->getLevel()->setBlock($blockReplace, $this, true, true);
+		$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
 		return true;
 	}

src/pocketmine/block/PumpkinStem.php

@@ -49,7 +49,7 @@ class PumpkinStem extends Crops{
 				$ev = new BlockGrowEvent($this, $block);
 				$ev->call();
 				if(!$ev->isCancelled()){
-					$this->getLevel()->setBlock($this, $ev->getNewState(), true);
+					$this->getLevelNonNull()->setBlock($this, $ev->getNewState(), true);
 				}
 			}else{
 				for($side = 2; $side <= 5; ++$side){
@@ -64,7 +64,7 @@ class PumpkinStem extends Crops{
 					$ev = new BlockGrowEvent($side, BlockFactory::get(Block::PUMPKIN));
 					$ev->call();
 					if(!$ev->isCancelled()){
-						$this->getLevel()->setBlock($side, $ev->getNewState(), true);
+						$this->getLevelNonNull()->setBlock($side, $ev->getNewState(), true);
 					}
 				}
 			}

src/pocketmine/block/Quartz.php

@@ -58,7 +58,7 @@ class Quartz extends Solid{
 		if($this->getVariant() !== self::NORMAL){
 			$this->meta = PillarRotationHelper::getMetaFromFace($this->meta, $face);
 		}
-		return $this->getLevel()->setBlock($blockReplace, $this, true, true);
+		return $this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 	}
 
 	public function getToolType() : int{

src/pocketmine/block/Rail.php

@@ -71,6 +71,7 @@ class Rail extends BaseRail{
 	}
 
 	protected function getPossibleConnectionDirectionsOneConstraint(int $constraint) : array{
+		/** @var int[] $horizontal */
 		static $horizontal = [
 			Vector3::SIDE_NORTH,
 			Vector3::SIDE_SOUTH,

src/pocketmine/block/RedMushroom.php

@@ -45,14 +45,14 @@ class RedMushroom extends Flowable{
 
 	public function onNearbyBlockChange() : void{
 		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($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->isTransparent()){
-			$this->getLevel()->setBlock($blockReplace, $this, true, true);
+			$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
 			return true;
 		}

src/pocketmine/block/RedstoneOre.php

@@ -47,16 +47,16 @@ class RedstoneOre extends Solid{
 	}
 
 	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
-		return $this->getLevel()->setBlock($this, $this, true, false);
+		return $this->getLevelNonNull()->setBlock($this, $this, true, false);
 	}
 
 	public function onActivate(Item $item, Player $player = null) : bool{
-		$this->getLevel()->setBlock($this, BlockFactory::get(Block::GLOWING_REDSTONE_ORE, $this->meta));
+		$this->getLevelNonNull()->setBlock($this, BlockFactory::get(Block::GLOWING_REDSTONE_ORE, $this->meta));
 		return false; //this shouldn't prevent block placement
 	}
 
 	public function onNearbyBlockChange() : void{
-		$this->getLevel()->setBlock($this, BlockFactory::get(Block::GLOWING_REDSTONE_ORE, $this->meta));
+		$this->getLevelNonNull()->setBlock($this, BlockFactory::get(Block::GLOWING_REDSTONE_ORE, $this->meta));
 	}
 
 	public function getToolType() : int{

src/pocketmine/block/Sapling.php

@@ -59,7 +59,7 @@ class Sapling extends Flowable{
 	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::GRASS or $down->getId() === self::DIRT or $down->getId() === self::FARMLAND){
-			$this->getLevel()->setBlock($blockReplace, $this, true, true);
+			$this->getLevelNonNull()->setBlock($blockReplace, $this, true, true);
 
 			return true;
 		}
@@ -70,9 +70,9 @@ class Sapling extends Flowable{
 	public function onActivate(Item $item, Player $player = null) : bool{
 		if($item->getId() === Item::DYE and $item->getDamage() === 0x0F){ //Bonemeal
 			//TODO: change log type
-			Tree::growTree($this->getLevel(), $this->x, $this->y, $this->z, new Random(mt_rand()), $this->getVariant());
+			Tree::growTree($this->getLevelNonNull(), $this->x, $this->y, $this->z, new Random(mt_rand()), $this->getVariant());
 
-			$item->count--;
+			$item->pop();
 
 			return true;
 		}
@@ -82,7 +82,7 @@ class Sapling extends Flowable{
 
 	public function onNearbyBlockChange() : void{
 		if($this->getSide(Vector3::SIDE_DOWN)->isTransparent()){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}
 	}
 
@@ -93,10 +93,10 @@ class Sapling extends Flowable{
 	public function onRandomTick() : void{
 		if($this->level->getFullLightAt($this->x, $this->y, $this->z) >= 8 and mt_rand(1, 7) === 1){
 			if(($this->meta & 0x08) === 0x08){
-				Tree::growTree($this->getLevel(), $this->x, $this->y, $this->z, new Random(mt_rand()), $this->getVariant());
+				Tree::growTree($this->getLevelNonNull(), $this->x, $this->y, $this->z, new Random(mt_rand()), $this->getVariant());
 			}else{
 				$this->meta |= 0x08;
-				$this->getLevel()->setBlock($this, $this, true);
+				$this->getLevelNonNull()->setBlock($this, $this, true);
 			}
 		}
 	}

src/pocketmine/block/SignPost.php

@@ -57,19 +57,18 @@ class SignPost extends Transparent{
 		return null;
 	}
 
-
 	public function place(Item $item, Block $blockReplace, Block $blockClicked, int $face, Vector3 $clickVector, Player $player = null) : bool{
 		if($face !== Vector3::SIDE_DOWN){
 
 			if($face === Vector3::SIDE_UP){
 				$this->meta = $player !== null ? (floor((($player->yaw + 180) * 16 / 360) + 0.5) & 0x0f) : 0;
-				$this->getLevel()->setBlock($blockReplace, $this, true);
+				$this->getLevelNonNull()->setBlock($blockReplace, $this, true);
 			}else{
 				$this->meta = $face;
-				$this->getLevel()->setBlock($blockReplace, BlockFactory::get(Block::WALL_SIGN, $this->meta), true);
+				$this->getLevelNonNull()->setBlock($blockReplace, BlockFactory::get(Block::WALL_SIGN, $this->meta), true);
 			}
 
-			Tile::createTile(Tile::SIGN, $this->getLevel(), TileSign::createNBT($this, $face, $item, $player));
+			Tile::createTile(Tile::SIGN, $this->getLevelNonNull(), TileSign::createNBT($this, $face, $item, $player));
 
 			return true;
 		}
@@ -79,7 +78,7 @@ class SignPost extends Transparent{
 
 	public function onNearbyBlockChange() : void{
 		if($this->getSide(Vector3::SIDE_DOWN)->getId() === self::AIR){
-			$this->getLevel()->useBreakOn($this);
+			$this->getLevelNonNull()->useBreakOn($this);
 		}
 	}
 

src/pocketmine/block/Skull.php

@@ -65,8 +65,8 @@ class Skull extends Flowable{
 		}
 
 		$this->meta = $face;
-		$this->getLevel()->setBlock($blockReplace, $this, true);
-		Tile::createTile(Tile::SKULL, $this->getLevel(), TileSkull::createNBT($this, $face, $item, $player));
+		$this->getLevelNonNull()->setBlock($blockReplace, $this, true);
+		Tile::createTile(Tile::SKULL, $this->getLevelNonNull(), TileSkull::createNBT($this, $face, $item, $player));
 
 		return true;
 	}