Implement waiting login sequence

src/Server.php

@@ -569,34 +569,42 @@ public function createPlayer(NetworkSession $session, PlayerInfo $playerInfo, bo
 		/** @phpstan-var PromiseResolver<Player> $playerPromiseResolver */
 		$playerPromiseResolver = new PromiseResolver();
 
-		$createPlayer = function(Location $location) use ($playerPromiseResolver, $class, $session, $playerInfo, $authenticated, $offlinePlayerData) : void{
+		$playerCreation = function(Location $location) use ($class, $session, $playerInfo, $authenticated, $offlinePlayerData, $playerPromiseResolver) : void{
+			if(!$session->isConnected()){
+				$playerPromiseResolver->reject();
+				return;
+			}
+
 			$player = new $class($this, $session, $playerInfo, $authenticated, $location, $offlinePlayerData);
 			if(!$player->hasPlayedBefore()){
 				$player->onGround = true; //TODO: this hack is needed for new players in-air ticks - they don't get detected as on-ground until they move
 			}
 			$playerPromiseResolver->resolve($player);
 		};
 
-		$ev->getWaitGroup()->wait(function() use ($playerPos, $world, $playerPromiseResolver, $session, $createPlayer) : void{
+		$playerCreationRejected = function (Translatable|string $message) use ($playerPromiseResolver, $session) : void {
+			if($session->isConnected()){
+				$session->disconnectWithError($message);
+			}
+			$playerPromiseResolver->reject();
+		};
+
+		$promise = Promise::all($ev->getPromises());
+		$promise->onCompletion(function () use ($playerPos, $world, $playerCreation, $playerCreationRejected) : void {
 			if($playerPos === null){ //new player or no valid position due to world not being loaded
 				$world->requestSafeSpawn()->onCompletion(
-					function(Position $spawn) use ($createPlayer, $playerPromiseResolver, $session, $world) : void{
-						if(!$session->isConnected()){
-							$playerPromiseResolver->reject();
-							return;
-						}
-						$createPlayer(Location::fromObject($spawn, $world));
+					function(Position $spawn) use ($playerCreation, $world) : void{
+						$playerCreation(Location::fromObject($spawn, $world));
 					},
-					function() use ($playerPromiseResolver, $session) : void{
-						if($session->isConnected()){
-							$session->disconnectWithError(KnownTranslationFactory::pocketmine_disconnect_error_respawn());
-						}
-						$playerPromiseResolver->reject();
+					function() use ($playerCreationRejected) : void{
+						$playerCreationRejected(KnownTranslationFactory::pocketmine_disconnect_error_respawn());
 					}
 				);
 			}else{ //returning player with a valid position - safe spawn not required
-				$createPlayer($playerPos);
+				$playerCreation($playerPos);
 			}
+		}, function () use ($playerCreationRejected) : void {
+			$playerCreationRejected("Failed to create player");
 		});
 
 		return $playerPromiseResolver->getPromise();

src/event/player/PlayerCreationEvent.php

@@ -26,16 +26,15 @@
 use pocketmine\event\Event;
 use pocketmine\network\mcpe\NetworkSession;
 use pocketmine\player\Player;
+use pocketmine\promise\Promise;
 use pocketmine\utils\Utils;
-use pocketmine\utils\WaitGroup;
 use function is_a;
 
 /**
  * Allows the use of custom Player classes. This enables overriding built-in Player methods to change behaviour that is
  * not possible to alter any other way.
  *
- * Allows the plugins to specify tasks that need to be executed before the login sequence take place, use WaitGroup to
- * manage synchronization between tasks.
+ * Allows the plugins to specify promise that need to be completed before the login sequence take place.
  *
  * You probably don't need this event, and found your way here because you looked at some code in an old plugin that
  * abused it (very common). Instead of using custom player classes, you should consider making session classes instead.
@@ -55,10 +54,10 @@ class PlayerCreationEvent extends Event{
 	private string $baseClass = Player::class;
 	/** @phpstan-var class-string<Player> */
 	private string $playerClass = Player::class;
-	private WaitGroup $waitGroup;
+	/** @phpstan-var Promise<mixed>[] $promises */
+	private array $promises = [];
 
 	public function __construct(private NetworkSession $session){
-		$this->waitGroup = new WaitGroup();
 	}
 
 	public function getNetworkSession() : NetworkSession{
@@ -118,18 +117,24 @@ public function setPlayerClass(string $class) : void{
 	}
 
 	/**
-	 * The typical use cases for this WaitGroup include:
-	 *  - Carrying out preparatory tasks such as configuring default preferences, setting
-	 * player-specific settings, or initializing in-game assets.
-	 *  - Loading initial player data from external sources or databases before the login sequence begins.
-	 *  - Providing a tailored welcome experience, which might involve sending messages,
-	 * granting starter items, or awarding initial rewards.
+	 * Retrieves all promises that have been added to the event.
+	 * These promises must be completed before the player login sequence is initiated.
 	 *
-	 * Note:
-	 *  After each task is completed, it's essential to call the `done` method of the WaitGroup
-	 *  to signal its completion and allow the WaitGroup to determine when to proceed.
+	 * @return Promise[]
+	 * @phpstan-return Promise<mixed>[]
 	 */
-	public function getWaitGroup() : WaitGroup{
-		return $this->waitGroup;
+	public function getPromises() : array{
+		return $this->promises;
+	}
+
+	/**
+	 * Adds a promise to the waiting list for the login sequence.
+	 * Once all the promises that have been added have been completed,
+	 * the player login sequence will be initiated and the player will be created.
+	 *
+	 * @param Promise<mixed> $promise
+	 */
+	public function addPromise(Promise $promise) : void{
+		$this->promises[] = $promise;
 	}
 }

src/promise/Promise.php

@@ -52,4 +52,52 @@
 	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.
+	 *
+	 * @phpstan-param Promise<mixed>[] $promises
+	 *
+	 * @phpstan-return Promise<array<int, mixed>>
+	 */
+	public static function all(array $promises) : Promise {
+		/** @phpstan-var PromiseResolver<array<int, mixed>> $resolver */
+		$resolver = new PromiseResolver();
+		$values = [];
+		$toResolve = 0;
+		$continue = true;
+
+		foreach($promises as $key => $promise){
+			$toResolve++;
+			$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{
+					$continue = false;
+					$resolver->reject();
+				}
+			);
+
+			if(!$continue){
+				break;
+			}
+		}
+
+		if($toResolve === 0){
+			$continue = false;
+			$resolver->resolve($values);
+		}
+
+		return $resolver->getPromise();
+	}
 }

tests/phpstan/configs/actual-problems.neon

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