Hangman\Entity\Hangman

Complexity

Total Complexity

77

Size/Duplication

Total Lines	764
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	22

Test Coverage

Coverage

97.99%

Importance

Changes	1
Bugs	0	Features	0

40 Methods

Rating	Name	Duplication	Size	Complexity
A	canPlayerPlay()	0	4	2
B	startGame()	0	29	3
A	getPlayer()	0	8	3
A	getCurrentPlayer()	0	4	1
A	getPlayers()	0	4	1
A	isGameStarted()	0	4	1
A	__construct()	0	4	1
A	getId()	0	4	1
A	getAggregateRootId()	0	4	1
A	getName()	0	4	1
B	addPlayerToGame()	0	30	3
B	leaveGame()	0	16	5
A	initialize()	0	4	1
A	playProposition()	0	9	2
A	playAnswer()	0	19	3
A	ensurePlayerCanPlay()	0	20	3
A	currentPlayerProposeLetter()	0	11	2
A	currentPlayerProposeAnswer()	0	10	2
A	currentPlayerBadProposition()	0	14	2
A	currentPlayerGoodProposition()	0	14	2
A	playerWins()	0	13	4
A	playerLoses()	0	21	4
A	setNextPlayer()	0	10	4
A	getNextPlayerId()	0	20	3
A	buildWord()	0	4	1
A	isAllLettersFoundForPlayer()	0	6	1
A	checkAnswerIsValid()	0	6	2
A	thereIsAnInGamePlayer()	0	12	3
A	applyHangmanGameCreatedEvent()	0	8	1
A	applyHangmanPlayerCreatedEvent()	0	13	1
A	applyHangmanGameStartedEvent()	0	4	1
A	applyHangmanPlayerTurnEvent()	0	4	1
A	applyHangmanPlayerLostEvent()	0	4	1
A	applyHangmanPlayerWinEvent()	0	5	1
A	applyHangmanGameLostEvent()	0	5	1
A	getChildEntities()	0	4	1
A	createGame()	0	7	1
A	instantiateForReconstitution()	0	4	1
A	apply()	0	8	2
A	isSupportedEvent()	0	7	3

<?php

namespace Hangman\Entity;

use Broadway\EventSourcing\EventSourcedAggregateRoot;
use Hangman\Event\HangmanGameCreatedEvent;
use Hangman\Event\HangmanGameFailedStartingEvent;
use Hangman\Event\HangmanGameLostEvent;
use Hangman\Event\HangmanGameStartedEvent;
use Hangman\Event\HangmanPlayerCreatedEvent;
use Hangman\Event\HangmanPlayerFailedCreatingEvent;
use Hangman\Event\HangmanPlayerLostEvent;
use Hangman\Event\HangmanPlayerProposedInvalidAnswerEvent;
use Hangman\Event\HangmanPlayerTriedPlayingDuringAnotherPlayerTurnEvent;
use Hangman\Event\HangmanPlayerTriedPlayingInactiveGameEvent;
use Hangman\Event\HangmanPlayerTurnEvent;
use Hangman\Exception\HangmanException;
use Hangman\Exception\HangmanPlayerOptionsException;
use Hangman\Move\Answer;
use Hangman\Move\Proposition;
use Hangman\Options\HangmanPlayerOptions;
use Hangman\Result\HangmanBadProposition;
use Hangman\Result\HangmanGoodProposition;
use Hangman\Result\HangmanLost;
use Hangman\Result\HangmanWon;
use Hangman\Word;
use MiniGame\Entity\MiniGame;
use MiniGame\Entity\MiniGameId;
use MiniGame\Entity\Player;
use MiniGame\Entity\PlayerId;
use MiniGame\Entity\PlayTrait;
use MiniGame\GameResult;
use MiniGame\PlayerOptions;

class Hangman extends EventSourcedAggregateRoot implements MiniGame
{
    use PlayTrait;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////   CONSTANTS   ///////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    const STATE_UNINITIALIZED = 'uninitialized';
    const STATE_READY = 'ready';
    const STATE_STARTED = 'started';
    const STATE_OVER = 'over';

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////   PROPERTIES   ///////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * @var MiniGameId
     */
    private $id;

    /**
     * @var Word
     */
    private $word;

    /**
     * @var HangmanPlayer[]
     **/
    private $players;

    /**
     * @var array
     */
    protected $gameOrder;

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

    /**
     * @var string
     */
    private $state;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////   PRIVATE CONSTRUCTOR   //////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Constructor
     */
    private function __construct()
    {
        $this->state = self::STATE_UNINITIALIZED;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////   ACCESSORS   ///////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Returns the id of the game
     *
     * @return MiniGameId
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Returns the aggregate id
     *
     * @return MiniGameId
     */
    public function getAggregateRootId()
    {
        return $this->id;
    }

    /**
     * Returns the name of the mini-game
     *
     * @return string
     */
    public static function getName()
    {
        return 'HANGMAN';
    }

    /**
     * Get the player identified by PlayerId
     *
     * @param PlayerId $playerId
     *
     * @return HangmanPlayer
     */
    public function getPlayer(PlayerId $playerId = null)
    {
        if ($playerId === null) {
            return null;
        }

        return isset($this->players[(string)$playerId]) ? $this->players[(string)$playerId] : null;
    }

    /**
     * Returns the player who can play
     *
     * @return Player
     */
    public function getCurrentPlayer()
    {
        return $this->currentPlayer;
    }

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

    /**
     * Is game started?
     *
     * @return bool
     */
    public function isGameStarted()
    {
        return $this->state === self::STATE_STARTED;
    }

    /**
     * Is it the player's turn?
     *
     * @param PlayerId $playerId
     *
     * @return bool
     */
    public function canPlayerPlay(PlayerId $playerId)
    {
        return $this->currentPlayer && $this->currentPlayer->getId()->equals($playerId);
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////   DOMAIN METHODS   /////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Starts the game
     *
     * @param PlayerId $playerId
     *
     * @return GameResult
     */
    public function startGame(PlayerId $playerId)
    {
        if ($this->state !== self::STATE_READY) {
            $event = new HangmanGameFailedStartingEvent(
                $this->id,
                $playerId,
                HangmanGameFailedStartingEvent::BAD_STATE
            );
            $this->apply($event);
            return $event;
        }

        if (count($this->players) === 0) {
            $event = new HangmanGameFailedStartingEvent(
                $this->id,
                $playerId,
                HangmanGameFailedStartingEvent::NO_PLAYER
            );
            $this->apply($event);
            return $event;
        }

        $event = new HangmanGameStartedEvent($this->id, $playerId);
        $this->apply($event);

        $this->setNextPlayer($playerId);

        return $event;
    }

    /**
     * Adds a player to the game
     *
     * @param PlayerOptions $playerOptions
     *
     * @throws HangmanPlayerOptionsException
     * @throws HangmanException
     *
     * @return GameResult
     */
    public function addPlayerToGame(PlayerOptions $playerOptions)
    {
        if (! $playerOptions instanceof HangmanPlayerOptions) {
            throw new HangmanPlayerOptionsException(
                $playerOptions->getPlayerId(),
                $this->getId(),
                'Options are not recognized'
            );
        }

        if ($this->state !== self::STATE_READY) {
            $event = new HangmanPlayerFailedCreatingEvent(
                $this->id,
                $playerOptions->getPlayerId(),
                $playerOptions->getExternalReference()
            );
            $this->apply($event);
            return $event;
        }

        $event = new HangmanPlayerCreatedEvent(
            $this->id,
            $playerOptions->getPlayerId(),
            $playerOptions->getName(),
            $playerOptions->getLives(),
            $playerOptions->getExternalReference()
        );
        $this->apply($event);
        return $event;
    }

    /**
     * A player leaves the game
     *
     * @param PlayerId $playerId
     *
     * @return GameResult
     */
    public function leaveGame(PlayerId $playerId)
    {
        switch ($this->state) {
            case self::STATE_STARTED:
                $player = $this->getPlayer($playerId);
                return $player ? $this->playerLoses($player) : null;
            case self::STATE_OVER:
                break;
            default:
                if (isset($this->players[(string) $playerId])) {
                    unset($this->players[(string) $playerId]);
                }
                break;
        }
        return null;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////   PRIVATE METHODS   /////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Initialize the game
     *
     * @param MiniGameId             $id
     * @param string                 $word
     */
    private function initialize(MiniGameId $id, $word)
    {
        $this->apply(new HangmanGameCreatedEvent($id, $word));
    }

    /**
     * Player proposes a letter
     *
     * @param PlayerId $playerId
     * @param Proposition $move
     *
     * @return GameResult
     */
    private function playProposition(PlayerId $playerId, Proposition $move)
    {
        if ($errorEvent = $this->ensurePlayerCanPlay($playerId)) {
            $this->apply($errorEvent);
            return $errorEvent;
        }

        return $this->currentPlayerProposeLetter($move->getText());
    }

    /**
     * Player tries an answer
     *
     * @param PlayerId $playerId
     * @param Answer $move
     *
     * @return GameResult
     */
    private function playAnswer(PlayerId $playerId, Answer $move)
    {
        if ($errorEvent = $this->ensurePlayerCanPlay($playerId)) {
            $this->apply($errorEvent);
            return $errorEvent;
        }

        try {
            return $this->currentPlayerProposeAnswer($move->getText());
        } catch (HangmanException $e) {
            $event = new HangmanPlayerProposedInvalidAnswerEvent(
                $this->getId(),
                $playerId,
                $move
            );
            $this->apply($event);
            return $event;
        }
    }

    /**
     * Returns an error event if player cannot play
     *
     * @param PlayerId $playerId
     *
     * @return GameResult
     */
    private function ensurePlayerCanPlay(PlayerId $playerId)
    {
        if (!$this->isGameStarted()) {
            $event = new HangmanPlayerTriedPlayingInactiveGameEvent(
                $this->getId(),
                $playerId
            );
            return $event;
        }

        if (!$this->canPlayerPlay($playerId)) {
            $event = new HangmanPlayerTriedPlayingDuringAnotherPlayerTurnEvent(
                $this->getId(),
                $playerId
            );
            return $event;
        }

        return null;
    }

    /**
     * Propose a letter
     *
     * @param string $letter
     *
     * @return HangmanBadProposition | HangmanGoodProposition
     */
    private function currentPlayerProposeLetter($letter)
    {
        $capLetter = strtoupper($letter);
        $letterPresent = $this->word->contains($capLetter);

        $result =  (!$letterPresent)
                   ? $this->currentPlayerBadProposition($letter) // remove a life
                   : $this->currentPlayerGoodProposition($letter); // yay!

        return $result;
    }

    /**
     * Propose an answer
     *
     * @param string $answer
     *
     * @return HangmanLost | HangmanWon
     */
    private function currentPlayerProposeAnswer($answer)
    {
        $this->checkAnswerIsValid($answer);

        if ($this->word->equals($answer)) {
            return $this->playerWins($this->currentPlayer); // you win
        } else {
            return $this->playerLoses($this->currentPlayer); // you lose
        }
    }

    /**
     * Function to call when a bad proposition has been made
     *
     * @param string $letter
     *
     * @return HangmanBadProposition | HangmanLost
     */
    private function currentPlayerBadProposition($letter)
    {
        $player = $this->currentPlayer;

        $event = $player->playBadLetter($letter, 1);

        if ($event->getRemainingLives() === 0) {
            return $this->playerLoses($player);
        }

        $this->setNextPlayer($this->getNextPlayerId());

        return $event;
    }

    /**
     * Function to call after a good proposition of letter has been made
     *
     * @param string $letter
     *
     * @return HangmanGoodProposition | HangmanWon
     */
    private function currentPlayerGoodProposition($letter)
    {
        $player = $this->currentPlayer;

        $event = $player->playGoodLetter($letter);

        if ($this->isAllLettersFoundForPlayer($player)) {
            return $this->playerWins($player);
        }

        $this->setNextPlayer($this->getNextPlayerId());

        return $event;
    }

    /**
     * Function to call when game is won by a player
     *
     * @param HangmanPlayer $player
     *
     * @return HangmanWon
     */
    private function playerWins(HangmanPlayer $player)
    {
        $event = $player->win($this->word);

        foreach ($this->players as $otherPlayer) {
            if ($otherPlayer->equals($player) || $otherPlayer->hasLost()) {
                continue;
            }
            $otherPlayer->lose($this->word);
        }

        return $event;
    }

    /**
     * Function to call when game is lost by a player
     *
     * @param HangmanPlayer $player
     *
     * @return hangmanLost | HangmanGameLostEvent
     */
    private function playerLoses(HangmanPlayer $player)
    {
        $event = $player->lose($this->word);

        if ($this->thereIsAnInGamePlayer() &&
            $this->currentPlayer &&
            $player->equals($this->currentPlayer)
        ) {
            $this->setNextPlayer($this->getNextPlayerId());
            return $event;
        }

        $event = new HangmanGameLostEvent(
            $this->id,
            $player->getId(),
            (string) $this->word
        );
        $this->apply($event);

        return $event;
    }

    /**
     * Sets the next player
     *
     * @param PlayerId $id
     */
    private function setNextPlayer(PlayerId $id = null)
    {
        if ($id === null || ($this->currentPlayer && $this->currentPlayer->getId()->equals($id))) {
            return;
        }

        $this->apply(
            new HangmanPlayerTurnEvent($this->getId(), $id)
        );
    }

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

        $pos = $nextPlayerPosition;
        do {
            $id = PlayerId::create($this->gameOrder[$pos]);
            $player = $this->getPlayer($id);

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

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

        return null;
    }

    /**
     * Build the word from played letters
     *
     * @param string[] $playedLetters
     *
     * @return string
     */
    public function buildWord($playedLetters)
    {
        return $this->word->buildWord($playedLetters);
    }

    /**
     * Checks if all letters for the word have been found
     *
     * @param HangmanPlayer $player
     *
     * @return bool
     */
    private function isAllLettersFoundForPlayer(HangmanPlayer $player)
    {
        $wordLetters = $this->word->getLetters();
        $playerLetters = $player->getPlayedLetters();
        return count(array_intersect($wordLetters, $playerLetters)) == count($wordLetters);
    }

    /**
     * Checks if the answer is valid
     * If it's not, ends player turn and throws an HangmanException
     *
     * @param string $answer
     *
     * @throws HangmanException
     */
    private function checkAnswerIsValid($answer)
    {
        if (! $this->word->isValid($answer)) {
            throw new HangmanException(sprintf('"%s" is not a valid answer!', $answer));
        }
    }

    /**
     * @return bool
     */
    private function thereIsAnInGamePlayer()
    {
        foreach ($this->gameOrder as $gameOrder) {
            $player = $this->getPlayer(PlayerId::create($gameOrder));

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

        return false;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////   APPLY EVENTS   //////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Apply the game created event
     *
     * @param HangmanGameCreatedEvent $event
     *
     * @return void
     */
    protected function applyHangmanGameCreatedEvent(HangmanGameCreatedEvent $event)
    {
        $this->id = $event->getGameId();
        $this->word = new Word($event->getWord());
        $this->players = [];
        $this->gameOrder = [];
        $this->state = self::STATE_READY;
    }

    /**
     * Apply the player created event
     *
     * @param HangmanPlayerCreatedEvent $event
     *
     * @return void
     */
    protected function applyHangmanPlayerCreatedEvent(HangmanPlayerCreatedEvent $event)
    {
        $player = new HangmanPlayer(
            $event->getPlayerId(),
            $event->getPlayerName(),
            $event->getLives(),
            $this,
            $event->getExternalReference()
        );

        $this->gameOrder[] = (string)$player->getId();
        $this->players[(string)$player->getId()] = $player;
    }

    /**
     * Apply the game created event
     */
    protected function applyHangmanGameStartedEvent()
    {
        $this->state = self::STATE_STARTED;
    }

    /**
     * Apply the player turn event
     *
     * @param HangmanPlayerTurnEvent $event
     */
    protected function applyHangmanPlayerTurnEvent(HangmanPlayerTurnEvent $event)
    {
        $this->currentPlayer = $this->getPlayer($event->getPlayerId());
    }

    /**
     * Apply the hangman player lost event
     *
     * @param HangmanPlayerLostEvent $event
     */
    protected function applyHangmanPlayerLostEvent(HangmanPlayerLostEvent $event)

The parameter $event is not used and could be removed.

    {
        $this->state = self::STATE_OVER;
    }

    /**
     * Apply the hangman player win event
     *
     * @return void
     */
    protected function applyHangmanPlayerWinEvent()
    {
        $this->currentPlayer = null;
        $this->state = self::STATE_OVER;
    }

    /**
     * Apply the hangman lost by all event
     *
     * @return void
     */
    protected function applyHangmanGameLostEvent()
    {
        $this->currentPlayer = null;
        $this->state = self::STATE_OVER;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////   EVENT SOURCED   /////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////   STATIC CONSTRUCTOR   ///////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Create a new instance
     *
     * @param MiniGameId $id
     * @param string     $word
     *
     * @return Hangman
     */
    public static function createGame(MiniGameId $id, $word)
    {
        $hangman = new self();
        $hangman->initialize($id, $word);

        return $hangman;
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////   RECONSTITUTION   /////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * Static construction method for reconstitution
     *
     * @return Hangman
     */
    public static function instantiateForReconstitution()
    {
        return new self();
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////   APPLY RESTRICTIONS   ///////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /**
     * @param mixed $event
     */
    public function apply($event)
    {
        if (! $this->isSupportedEvent($event)) {
            return;
        }

        parent::apply($event);
    }

    /**
     * @param mixed $event
     *
     * @return bool
     */
    private function isSupportedEvent($event)
    {
        return (
            $event instanceof GameResult &&
            ($this->id === null || $this->id == $event->getGameId())
        );
    }
}