Cysha\Casino\Holdem\Game\CashGame

Complexity

Total Complexity

15

Size/Duplication

Total Lines	177
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	setUp()	0	4	1
A	id()	0	4	1
A	name()	0	4	1
A	rules()	0	4	1
A	players()	0	4	1
A	__toString()	0	4	1
A	tables()	0	4	1
A	registerPlayer()	0	22	3
B	removePlayer()	0	29	3
A	assignPlayersToTables()	0	14	1

<?php

namespace Cysha\Casino\Holdem\Game;

use Cysha\Casino\Cards\Deck;
use Cysha\Casino\Exceptions\GameException;
use Cysha\Casino\Game\Chips;
use Cysha\Casino\Game\Client;
use Cysha\Casino\Game\Contracts\Game;
use Cysha\Casino\Game\Contracts\GameParameters;
use Cysha\Casino\Game\PlayerCollection;
use Cysha\Casino\Game\TableCollection;
use Cysha\Casino\Holdem\Cards\Evaluators\SevenCard;
use Ramsey\Uuid\Uuid;
use Ramsey\Uuid\UuidInterface;

final class CashGame implements Game
{
    /**
     * @var UuidInterface
     */
    private $id;

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

    /**
     * @var DefaultParameters
     */
    private $rules;

    /**
     * @var PlayerCollection
     */
    private $players;

    /**
     * @var TableCollection
     */
    protected $tables;

    /**
     * CashGame constructor.
     *
     * @param UuidInterface  $id
     * @param string         $name
     * @param GameParameters $rules
     */
    public function __construct(UuidInterface $id, string $name, GameParameters $rules)
    {
        $this->id = $id;
        $this->name = $name;
        $this->players = PlayerCollection::make();
        $this->tables = TableCollection::make();
        $this->rules = $rules;

It seems like $rules of type object<Cysha\Casino\Game\Contracts\GameParameters> is incompatible with the declared type object<Cysha\Casino\Holdem\Game\DefaultParameters> of property $rules.

    }

    /**
     * @param UuidInterface  $id
     * @param string         $name
     * @param GameParameters $rules
     *
     * @return CashGame
     */
    public static function setUp(UuidInterface $id, string $name, GameParameters $rules)
    {
        return new self($id, $name, $rules);
    }

    /**
     * @return UuidInterface
     */
    public function id(): UuidInterface
    {
        return $this->id;
    }

    /**
     * @return string
     */
    public function name(): string
    {
        return $this->name;
    }

    /**
     * @return GameParameters
     */
    public function rules(): GameParameters
    {
        return $this->rules;
    }

    /**
     * @return PlayerCollection
     */
    public function players(): PlayerCollection
    {
        return $this->players;
    }

    /**
     * @return string
     */
    public function __toString(): string
    {
        return $this->name;
    }

    /**
     * @return TableCollection
     */
    public function tables(): TableCollection
    {
        return $this->tables;
    }

    /**
     * @param Client $client
     * @param Chips  $buyinAmount
     *
     * @throws GameException
     */
    public function registerPlayer(Client $client, Chips $buyinAmount = null)
    {
        $buyinAmount = $buyinAmount ?? $this->rules()->minimumBuyIn();

It seems like you code against a concrete implementation and not the interface Cysha\Casino\Game\Contracts\GameParameters as the method minimumBuyIn() does only exist in the following implementations of said interface: Cysha\Casino\Holdem\Game\Parameters\CashGameParameters.

        $playerRegistered = $this->players()
            ->filter(function (Client $player) use ($client) {
                return $client->name() === $player->name();
            });

        if ($playerRegistered->count() !== 0) {
            throw GameException::alreadyRegistered($client, $this);
        }

        if ($buyinAmount->amount() > $client->wallet()->amount()) {
            throw GameException::insufficientFunds($client, $this);
        }

        $client->wallet()->subtract($buyinAmount);

        $addPlayer = Player::fromClient($client, $buyinAmount);
        $this->players()->push($addPlayer);
    }

    public function removePlayer(Client $client)
    {
        $player = $this->players()
            ->filter(function (Player $player) use ($client) {
                return $player->name() === $client->name();
            })
            ->first()
        ;

        if ($player === null) {
            throw GameException::notRegistered($client, $this);
        }

        $client->wallet()->add($player->chipstack());

        $this->players = $this->players()
            ->reject(function (Player $player) use ($client) {
                return $player->name() === $client->name();
            })
            ->values();

        $this->tables()
            ->each(function (Table $table) use ($client) {
                try {
                    $table->removePlayer($client);
                } catch (Cysha\Casino\Holdem\Exceptions\TableException $e) {

Consider adding a comment why this CATCH block is empty.

The class Cysha\Casino\Holdem\Game\Cysha\Casino\Holdem\Exceptions\TableException does not exist. Did you forget a USE statement, or did you not list all dependencies?

                }
            });
    }

    public function assignPlayersToTables()
    {
        $groupedPlayers = $this->players()
        //->shuffle()
            ->chunk($this->rules()->tableSize())
            ->map(function (PlayerCollection $players) {
                $dealer = Dealer::startWork(new Deck(), new SevenCard());

                return Table::setUp(Uuid::uuid4(), $dealer, $players);
            })
            ->toArray();

        $this->tables = TableCollection::make($groupedPlayers);
    }
}