Hangman\PlayersCollection

Complexity

Total Complexity

16

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

93.02%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	set()	0	9	1
A	add()	0	8	1
A	thereIsAtLeastOneActivePlayer()	0	13	3
A	getNextPlayerId()	0	19	3
A	getCurrentPlayer()	0	4	1
A	setCurrentPlayer()	0	4	2
A	isCurrentPlayer()	0	4	2
A	canPlayerPlay()	0	4	1
A	hasPlayers()	0	4	1

<?php

namespace Hangman;

use Assert\Assertion;
use Doctrine\Common\Collections\ArrayCollection;
use Hangman\Entity\HangmanPlayer;
use MiniGame\Entity\PlayerId;

class PlayersCollection extends ArrayCollection
{
    /**
     * @var array
     */
    private $gameOrder;

    /**
     * @var HangmanPlayer
     */
    private $currentPlayer;

    /**
     * @inheritDoc
     */
    public function __construct(array $elements = array())
    {
        parent::__construct($elements);

        $this->gameOrder = [];
    }

    /**
     * @param mixed         $key
     * @param HangmanPlayer $value
     */
    public function set($key, $value)
    {
        Assertion::isInstanceOf($value, HangmanPlayer::class);
        Assertion::eq($key, (string) $value->getId());

        parent::set($key, $value);

        $this->gameOrder[] = $key;
    }

    /**
     * @param HangmanPlayer $value
     *
     * @return bool
     */
    public function add($value)
    {
        Assertion::isInstanceOf($value, HangmanPlayer::class);

        $this->set((string) $value->getId(), $value);

        return true;
    }

    /**
     * @return bool
     */
    public function thereIsAtLeastOneActivePlayer()
    {
        foreach ($this->gameOrder as $gameOrder) {
            /** @var HangmanPlayer $player */
            $player = $this->get($gameOrder);

            if ($player->getState() === HangmanPlayer::STATE_IN_GAME) {
                return true;
            }
        }

        return false;
    }

    /**
     * Returns the next player in line
     *
     * @return PlayerId
     */
    public function getNextPlayerId()
    {
        $nbPlayers = count($this->gameOrder);
        $currentPlayerId = (string) $this->currentPlayer->getId();
        $nextPlayerPosition = (array_search($currentPlayerId, $this->gameOrder) + 1) % $nbPlayers;

        $pos = $nextPlayerPosition;
        do {
            $player = $this->get($this->gameOrder[$pos]);

            if ($player->getState() === HangmanPlayer::STATE_IN_GAME) {
                return PlayerId::create($this->gameOrder[$pos]);
            }

            $pos = ($pos + 1) % $nbPlayers;
        } while ($pos !== $nextPlayerPosition);

        return null;
    }

    /**
     * @return HangmanPlayer
     */
    public function getCurrentPlayer()
    {
        return $this->currentPlayer;
    }

    /**
     * @param PlayerId $playerId
     */
    public function setCurrentPlayer(PlayerId $playerId = null)
    {
        $this->currentPlayer = ($playerId !== null) ? $this->get((string) $playerId) : null;
    }

    /**
     * @param PlayerId $playerId
     *
     * @return bool
     */
    public function isCurrentPlayer(PlayerId $playerId = null)
    {
        return $this->currentPlayer !== null && $this->currentPlayer->getId()->equals($playerId);

It seems like $playerId defined by parameter $playerId on line 123 can be null; however, MiniGame\Entity\PlayerId::equals() does not accept null, maybe add an additional type check?

    }

    /**
     * @param PlayerId $playerId
     *
     * @return bool
     */
    public function canPlayerPlay(PlayerId $playerId)
    {
        return $this->isCurrentPlayer($playerId);
    }

    public function hasPlayers()
    {
        return $this->count() > 0;
    }
}