AbstractTeamRuleTrait::calculateTeamValue() - Code Metrics - Inspection of "Merge pull request #5 from obblm/develop" - obblm/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c1ba47...3b776f )

by Benjamin

created 2020-09-29 12:34 UTC

AbstractTeamRuleTrait::calculateTeamValue() B

↳ Parent: AbstractTeamRuleTrait

Complexity

Conditions	9
Paths	13

Size

Total Lines	31
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	9
eloc	20
c	1
b	0
f	0
nc	13
nop	2
dl	0
loc	31
rs	8.0555

<?php

namespace Obblm\Core\Helper\Rule\Traits;

use Doctrine\Common\Collections\ArrayCollection;
use Obblm\Core\Entity\PlayerVersion;
use Obblm\Core\Entity\Team;
use Obblm\Core\Entity\TeamVersion;
use Obblm\Core\Exception\InvalidArgumentException;
use Obblm\Core\Exception\NotFoundRuleKeyExcepion;
use Obblm\Core\Exception\NoVersionException;
use Obblm\Core\Helper\PlayerHelper;
use Obblm\Core\Helper\Rule\Roster\Roster;
use Obblm\Core\Validator\Constraints\TeamValue;

/****************************
 * TEAM INFORMATION METHODS
 ***************************/
trait AbstractTeamRuleTrait
{
    public function getAvailableRosters(): ArrayCollection
    {
        return $this->getRosters();
        return $this->/** @scrutinizer ignore-call */ getRosters();
    }

    /**
     * @return int
     */
    public function getMaxTeamCost():int
    {
        return ($this->rule['max_team_cost']) ? $this->rule['max_team_cost'] : TeamValue::LIMIT;
    }

    /**
     * @param Team $team
     * @return array
     */
    public function getTeamAvailablePlayerTypes(Team $team)
    {
        return $this->getAvailablePlayerTypes($team->getRoster());
        return $this->/** @scrutinizer ignore-call */ getAvailablePlayerTypes($team->getRoster());
    }

    /**
     * @param Team $team
     * @return int
     * @throws \Exception
     */
    public function getRerollCost(Team $team):int
    {
        /** @var Roster $roster */
        $roster = $this->getRosters()->get($team->getRoster());
        return (int) $roster->getRerollCost();
    }

    /**
     * @param Team $team
     * @return int
     */
    public function getApothecaryCost(Team $team):int
    public function getApothecaryCost(/** @scrutinizer ignore-unused */ Team $team):int
    {
        return (int) $this->rule['sidelines_cost']['apothecary'];
    }

    /**
     * @param Team $team
     * @return int
     */
    public function getCheerleadersCost(Team $team):int
    public function getCheerleadersCost(/** @scrutinizer ignore-unused */ Team $team):int
    {
        return (int) $this->rule['sidelines_cost']['cheerleaders'];
    }

    /**
     * @param Team $team
     * @return int
     */
    public function getAssistantsCost(Team $team):int
    public function getAssistantsCost(/** @scrutinizer ignore-unused */ Team $team):int
    {
        return (int) $this->rule['sidelines_cost']['assistants'];
    }

    /**
     * @param Team $team
     * @return int
     */
    public function getPopularityCost(Team $team):int
    public function getPopularityCost(/** @scrutinizer ignore-unused */ Team $team):int
    {
        return (int) $this->rule['sidelines_cost']['popularity'];
    }

    /**
     * @param Team $team
     * @return bool
     * @throws \Exception
     */
    public function couldHaveApothecary(Team $team):bool
    {
        /** @var Roster $roster */
        $roster = $this->getRosters()->get($team->getRoster());
        return (bool) $roster->canHaveApothecary();
    }

    public function calculateTeamRate(TeamVersion $version):?int
    {
        return $this->calculateTeamValue($version) / 10000;
    }

    public function calculateTeamValue(TeamVersion $version, bool $excludeDisposable = false):int
    {
        if (!$version->getTeam()) {
            throw new InvalidArgumentException();
        }
        $value = 0;
        // Players
        // TODO: Bug => players are not version's one (because od dead players)
        foreach ($version->getTeam()->getAvailablePlayers() as $player) {
            if ($player->getType()) {
                try {
                    $playerVersion = PlayerHelper::getLastVersion($player);
                } catch (NoVersionException $e) { // It's a new player !
                    $playerVersion = (new PlayerVersion());
                    $player->addVersion($playerVersion);
                    $version->addPlayerVersion($playerVersion);
                    $this->setPlayerDefaultValues($playerVersion);
                }
                if (!$playerVersion->isMissingNextGame() && !($this->playerIsDisposable($playerVersion) && $excludeDisposable)) {
                    $value += $playerVersion->getValue();
                }
            }
        }
        // Sidelines
        $value += $version->getRerolls() * $this->getRerollCost($version->getTeam());
        $value += $version->getAssistants() * $this->getAssistantsCost($version->getTeam());
        $value += $version->getCheerleaders() * $this->getCheerleadersCost($version->getTeam());
        $value += $version->getPopularity() * $this->getPopularityCost($version->getTeam());
        $value += ($version->getApothecary()) ? $this->getApothecaryCost($version->getTeam()) : 0;

        return $value;
    }

    abstract public function setPlayerDefaultValues(PlayerVersion $version): ?PlayerVersion;
    abstract public function playerIsDisposable(PlayerVersion $version):bool;

    /**
     * @return array
     */
    public function getInjuriesTable():array
    {
        return $this->getInjuries();
        return $this->/** @scrutinizer ignore-call */ getInjuries();
    }

    public function getMaxPlayersByType($rosterKey, $typeKey): int
    {
        /** @var Roster $roster */
        $roster = $this->getRosters()->get($rosterKey);
        if (!$type = $roster->getPlayerTypes()[$typeKey]) {
            throw new NotFoundRuleKeyExcepion($typeKey, 'toto');
            throw new NotFoundRuleKeyExcepion($typeKey, /** @scrutinizer ignore-type */ 'toto');
        }
        return (int) $type['max'];
    }
}


obblm / core

Push — master ( c1ba47...3b776f )

AbstractTeamRuleTrait::calculateTeamValue() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like