AardsGerds\Game\Player\Player

Complexity

Total Complexity

13

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Test Coverage

Coverage

23.26%

Importance

Changes	7
Bugs	0	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getLevelProgress()	0	3	1
A	new()	0	17	1
A	increaseExperience()	0	3	1
A	calculateCorruptionBoundary()	0	17	3
A	getTalentPoints()	0	3	1
A	getAttributePoints()	0	3	1
A	__construct()	0	22	1
A	increaseEtherum()	0	19	4

<?php

declare(strict_types=1);

namespace AardsGerds\Game\Player;

use AardsGerds\Game\Build\Attribute\AttributePoints;
use AardsGerds\Game\Build\Attribute\Etherum;
use AardsGerds\Game\Build\Attribute\Health;
use AardsGerds\Game\Build\Attribute\Strength;
use AardsGerds\Game\Build\Experience;
use AardsGerds\Game\Build\Level;
use AardsGerds\Game\Build\LevelProgress;
use AardsGerds\Game\Build\Talent\SecretKnowledge\Ascension;
use AardsGerds\Game\Build\Talent\TalentCollection;
use AardsGerds\Game\Build\Talent\TalentPoints;
use AardsGerds\Game\Entity\Entity;
use AardsGerds\Game\Inventory\Inventory;
use AardsGerds\Game\Inventory\Weapon\Weapon;
use AardsGerds\Game\Shared\IntegerValueException;

final class Player extends Entity
{
    public function __construct(
        string $name,
        Health $health,
        Etherum $etherum,
        Strength $strength,
        TalentCollection $talentCollection,
        Inventory $inventory,
        ?Weapon $weapon,
        bool $corrupted,
        private LevelProgress $levelProgress,
        private AttributePoints $attributePoints,
        private TalentPoints $talentPoints,
    ) {
        parent::__construct(
            $name,
            $health,
            $etherum,
            $strength,
            $talentCollection,
            $inventory,
            $weapon,
            $corrupted,
        );
    }

    public static function new(string $name): self
    {
        return new self(
            $name,
            new Health(100),
            new Etherum(1),
            new Strength(5),
            new TalentCollection([]),
            new Inventory([]),
            null,
            false,
            new LevelProgress(
                new Level(1),
                new Experience(0),
            ),
            new AttributePoints(0),
            new TalentPoints(0),
        );
    }

    public function getLevelProgress(): LevelProgress
    {
        return $this->levelProgress;
    }

    public function increaseExperience(Experience $experience): void
    {
        $this->levelProgress->increase($experience, $this);
    }

    /**
     * @throws PlayerException
     */
    public function increaseEtherum(Etherum $etherum): void
    {
        $this->etherum->increaseBy($etherum);

        if ($this->isCorrupted()) {
            return;
        }

        $playerAscension = $this->talentCollection->findSecretKnowledge()?->getAscension()
            ?? throw PlayerException::etherumOverdose();

        $corruptionBoundary = $this->calculateCorruptionBoundary();

        if ($this->etherum->isGreaterThanOrEqual($corruptionBoundary)) {
            if ($playerAscension->isLowerThan(Ascension::sixthAscension())) {
                throw PlayerException::etherumOverdose();
            }

            $this->corrupted = true;
        }
    }

    public function getAttributePoints(): AttributePoints
    {
        return $this->attributePoints;
    }

    public function getTalentPoints(): TalentPoints
    {
        return $this->talentPoints;
    }

    private function calculateCorruptionBoundary(): Etherum
    {
        $ascension = $this->talentCollection->findSecretKnowledge()?->getAscension();
        if ($ascension === null) {
            return new Etherum(2);
        }

        try {
            $nextAscensionEtherum = $ascension->increment()->getRequiredEtherum();
        } catch (IntegerValueException $exception) {
            // entity has 8th ascension
            $nextAscensionEtherum = new Etherum($ascension->getRequiredEtherum()->get() * 2);
        }

        // etherum required by next ascension + 0.5 x etherum required by next ascension
        return $nextAscensionEtherum->increaseBy(
            new Etherum((int) ($nextAscensionEtherum->get() * 0.5)),
        );
    }
}