eXpansion\Framework\Core\Storage\PlayerStorage

Complexity

Total Complexity

19

Size/Duplication

Total Lines	187
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	10

Test Coverage

Coverage

83.05%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	onPostLoop()	0	4	1
A	onEverySecond()	0	4	1
A	__construct()	0	11	1
A	getPlayerInfo()	0	25	5
A	onPlayerConnect()	0	12	2
A	onPlayerDisconnect()	0	4	1
A	onPlayerInfoChanged()	0	7	1
A	onPlayerAlliesChanged()	0	4	1
A	getOnline()	0	4	1
A	getPlayers()	0	4	1
A	getSpectators()	0	4	1
A	onPreLoop()	0	10	2
A	getPlayersToRemove()	0	4	1

<?php

namespace eXpansion\Framework\Core\Storage;

use eXpansion\Framework\Core\DataProviders\Listener\ListenerInterfaceExpTimer;
use eXpansion\Framework\Core\Services\Console;
use eXpansion\Framework\Core\Services\DedicatedConnection\Factory;
use eXpansion\Framework\Core\Storage\Data\Player;
use eXpansion\Framework\Core\Storage\Data\PlayerFactory;
use eXpansion\Framework\GameManiaplanet\DataProviders\Listener\ListenerInterfaceMpLegacyPlayer;
use Maniaplanet\DedicatedServer\Connection;
use Maniaplanet\DedicatedServer\InvalidArgumentException;
use Maniaplanet\DedicatedServer\Structures\PlayerDetailedInfo;
use Maniaplanet\DedicatedServer\Structures\PlayerInfo;
use Maniaplanet\DedicatedServer\Xmlrpc\FaultException;
use Psr\Log\LoggerInterface;

/**
 * PlayerStorage keeps in storage player data in order to minimize amounts of calls done to the dedicated server.
 *
 * @package eXpansion\Framework\Core\Storage
 */
class PlayerStorage implements ListenerInterfaceMpLegacyPlayer, ListenerInterfaceExpTimer
{
    /** @var  Factory */
    protected $factory;

    /** @var PlayerFactory */
    protected $playerFactory;

    /** @var Player[] List of all the players on the server. */
    protected $online = [];

    /** @var Player[] List of all the players playing on the server. */
    protected $players = [];

    /** @var Player[] List of all spectators on the server. */
    protected $spectators = [];

    /** @var array */
    protected $playersToRemove = [];
    /**
     * @var LoggerInterface
     */
    private $logger;
    /**
     * @var Console
     */
    private $console;

    /**
     * PlayerDataProvider constructor.
     *
     * @param Factory         $factory
     * @param PlayerFactory   $playerFactory
     * @param LoggerInterface $logger
     * @param Console         $console
     */
    public function __construct(
        Factory $factory,
        PlayerFactory $playerFactory,
        LoggerInterface $logger,
        Console $console
    ) {
        $this->factory = $factory;
        $this->playerFactory = $playerFactory;
        $this->logger = $logger;
        $this->console = $console;
    }

    /**
     * Get information about a player.
     *
     * @param string $login
     * @param bool   $forceNew
     *
     * @return Player
     */
    public function getPlayerInfo($login, $forceNew = false)
    {
        if (!isset($this->online[$login]) || $forceNew) {
            // to make sure even if an exception happens, player has login and basic nickname
            $playerInformation = new PlayerInfo();
            $playerInformation->login = $login;
            $playerDetails = new PlayerDetailedInfo();
            $playerDetails->nickName = $login;

            try {
                //fetch additional informations
                $playerInformation = $this->factory->getConnection()->getPlayerInfo($login);
                $playerDetails = $this->factory->getConnection()->getDetailedPlayerInfo($login);
            } catch (InvalidArgumentException $e) {
                $this->logger->error("Login unknown: $login", ["exception" => $e]);
                $this->console->writeln('$f00Login Unknown: '.$login.' dedicated server said: $fff'.$e->getMessage());
            } catch (FaultException $ex) {
                $this->logger->error("Login unknown: $login", ["exception" => $ex]);
                $this->console->writeln('$f00Login Unknown: '.$login.' dedicated server said: $fff'.$ex->getMessage());
            }
            return $this->playerFactory->createPlayer($playerInformation, $playerDetails);
        }

        return $this->online[$login];
    }

    /**
     * Fetch player data & store it when player connects.
     *
     * @inheritdoc
     */
    public function onPlayerConnect(Player $playerData)
    {
        $login = $playerData->getLogin();

        $this->online[$login] = $playerData;

        if ($playerData->isSpectator()) {
            $this->spectators[$login] = $playerData;
        } else {
            $this->players[$login] = $playerData;
        }
    }

    /**
     * Remove player data when he disconnects.
     *
     * @inheritdoc
     */
    public function onPlayerDisconnect(Player $playerData, $disconnectionReason)
    {
        $this->playersToRemove[] = $playerData->getLogin();
    }

    /**
     * Change the status of the players.
     *
     * @inheritdoc
     */
    public function onPlayerInfoChanged(Player $oldPlayer, Player $player)
    {
        unset($this->players[$player->getLogin()]);
        unset($this->spectators[$player->getLogin()]);

        $this->onPlayerConnect($player);
    }

    /**
     * Modify the player object.
     *
     * @inheritdoc
     */
    public function onPlayerAlliesChanged(Player $oldPlayer, Player $player)
    {
        $this->onPlayerConnect($player);
    }

    /**
     * @return Player[]
     */
    public function getOnline()
    {
        return $this->online;
    }

    /**
     * @return Player[]
     */
    public function getPlayers()
    {
        return $this->players;
    }

    /**
     * @return Player[]
     */
    public function getSpectators()
    {
        return $this->spectators;
    }


    public function onPreLoop()
    {
        foreach ($this->playersToRemove as $login) {
            unset($this->online[$login]);
            unset($this->spectators[$login]);
            unset($this->players[$login]);
        }

        $this->playersToRemove = [];
    }

    public function onPostLoop()
    {
        // do nothing
    }

    public function onEverySecond()
    {
        // do nothing
    }

    /**
     * @return array
     */
    public function getPlayersToRemove()
    {
        return $this->playersToRemove;
    }
}