Implement waiting login sequence

src/Server.php

@@ -42,6 +42,7 @@
 use pocketmine\event\player\PlayerCreationEvent;
 use pocketmine\event\player\PlayerDataSaveEvent;
 use pocketmine\event\player\PlayerLoginEvent;
+use pocketmine\event\player\PlayerPreCreationEvent;
 use pocketmine\event\server\CommandEvent;
 use pocketmine\event\server\QueryRegenerateEvent;
 use pocketmine\lang\KnownTranslationFactory;
@@ -105,6 +106,7 @@
 use pocketmine\utils\MainLogger;
 use pocketmine\utils\NotCloneable;
 use pocketmine\utils\NotSerializable;
+use pocketmine\utils\ObjectSet;
 use pocketmine\utils\Process;
 use pocketmine\utils\SignalHandler;
 use pocketmine\utils\Terminal;
@@ -553,6 +555,31 @@ public function saveOfflinePlayerData(string $name, CompoundTag $nbtTag) : void{
 	 * @phpstan-return Promise<Player>
 	 */
 	public function createPlayer(NetworkSession $session, PlayerInfo $playerInfo, bool $authenticated, ?CompoundTag $offlinePlayerData) : Promise{
+		/** @var PromiseResolver<Player> $globalResolver */
+		$globalResolver = new PromiseResolver();
+
+		$this->preparePlayerCreation($session)->onCompletion(
+			function() use ($session, $playerInfo, $authenticated, $offlinePlayerData, $globalResolver) : void{
+				$this->createPlayerInternal($session, $playerInfo, $authenticated, $offlinePlayerData)->onCompletion(
+					function(Player $player) use ($globalResolver) : void {
+						$globalResolver->resolve($player);
+					}, function() use ($globalResolver) : void {
+						$globalResolver->reject();
+					}
+				);
+			},
+			function() use ($globalResolver) : void {
+				$globalResolver->reject();
+			}
+		);
+
+		return $globalResolver->getPromise();
+	}
+
+	/**
+	 * @phpstan-return Promise<Player>
+	 */
+	private function createPlayerInternal(NetworkSession $session, PlayerInfo $playerInfo, bool $authenticated, ?CompoundTag $offlinePlayerData) : Promise{
 		$ev = new PlayerCreationEvent($session);
 		$ev->call();
 		$class = $ev->getPlayerClass();
@@ -600,6 +627,18 @@ function() use ($playerPromiseResolver, $session) : void{
 		return $playerPromiseResolver->getPromise();
 	}
 
+	/**
+	 * @return Promise<array<int, null>>
+	 */
+	private function preparePlayerCreation(NetworkSession $session) : Promise{
+		/** @phpstan-var ObjectSet<Promise<null>> $promises */
+		$promises = new ObjectSet();
+		$ev = new PlayerPreCreationEvent($session, $promises);
+		$ev->call();
+
+		return Promise::all($promises->toArray());
+	}
+
 	/**
 	 * @deprecated This method's results are unpredictable. The string "Steve" will return the player named "SteveJobs",
 	 * until another player named "SteveJ" joins the server, at which point it will return that player instead. Prefer

src/event/player/PlayerPreCreationEvent.php

@@ -0,0 +1,63 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ *
+ *
+ */
+
+declare(strict_types=1);
+
+namespace pocketmine\event\player;
+
+use pocketmine\event\Event;
+use pocketmine\network\mcpe\NetworkSession;
+use pocketmine\promise\Promise;
+use pocketmine\utils\ObjectSet;
+
+/**
+ * Allows the plugins to specify promise that need to be completed before the PlayerCreationEvent is fired.
+ */
+class PlayerPreCreationEvent extends Event{
+	/** @phpstan-param ObjectSet<Promise<null>> $promises */
+	public function __construct(
+		private NetworkSession $session,
+		private ObjectSet $promises
+	){ }
+
+	public function getNetworkSession() : NetworkSession{
+		return $this->session;
+	}
+
+	public function getAddress() : string{
+		return $this->session->getIp();
+	}
+
+	public function getPort() : int{
+		return $this->session->getPort();
+	}
+
+	/**
+	 * Adds a promise to the waiting list.
+	 * Once all the promises that have been added have been completed,
+	 * the player creation sequence will continue and the PlayerCreationEvent will be fired.
+	 *
+	 * @phpstan-param Promise<null> $promise
+	 */
+	public function addPromise(Promise $promise) : void{
+		$this->promises->add($promise);
+	}
+}

src/network/mcpe/NetworkSession.php

@@ -100,6 +100,7 @@
 use pocketmine\player\PlayerInfo;
 use pocketmine\player\UsedChunkStatus;
 use pocketmine\player\XboxLivePlayerInfo;
+use pocketmine\promise\Promise;
 use pocketmine\Server;
 use pocketmine\timings\Timings;
 use pocketmine\utils\AssumptionFailedError;

src/promise/Promise.php

@@ -23,6 +23,7 @@
 
 namespace pocketmine\promise;
 
+use function count;
 use function spl_object_id;
 
 /**
@@ -52,4 +53,54 @@ public function onCompletion(\Closure $onSuccess, \Closure $onFailure) : void{
 	public function isResolved() : bool{
 		return $this->shared->resolved;
 	}
+
+	/**
+	 * Returns a promise that will resolve only once all the Promises in
+	 * `$promises` have resolved. The resolution value of the returned promise
+	 * will be an array containing the resolution values of each Promises in
+	 * `$promises` indexed by the respective Promises' array keys.
+	 *
+	 * @template TPromiseValue
+	 * @phpstan-param Promise<TPromiseValue>[] $promises
+	 *
+	 * @phpstan-return Promise<array<int, TPromiseValue>>
+	 */
+	public static function all(array $promises) : Promise {
+		/** @phpstan-var PromiseResolver<array<int, TPromiseValue>> $resolver */
+		$resolver = new PromiseResolver();
+		$values = [];
+		$toResolve = count($promises);
+		$continue = true;
+
+		foreach($promises as $key => $promise){
+			$values[$key] = null;
+
+			$promise->onCompletion(
+				function(mixed $value) use ($resolver, $key, &$toResolve, &$continue, &$values) : void{
+					$values[$key] = $value;
+
+					if(--$toResolve === 0 && $continue){
+						$resolver->resolve($values);
+					}
+				},
+				function() use ($resolver, &$continue) : void{
+					if($continue){
+						$continue = false;
+						$resolver->reject();
+					}
+				}
+			);
+
+			if(!$continue){
+				break;
+			}
+		}
+
+		if($toResolve === 0){
+			$continue = false;
+			$resolver->resolve($values);
+		}
+
+		return $resolver->getPromise();
+	}
 }

tests/phpstan/configs/actual-problems.neon

@@ -1205,3 +1205,8 @@ parameters:
 			count: 1
 			path: ../../phpunit/scheduler/AsyncPoolTest.php
 
+		-
+			message: "#^Right side of && is always true\\.$#"
+			count: 1
+			path: ../../../src/promise/Promise.php
+