Stu\Module\Ship\Lib\ReactorWrapper

Complexity

Total Complexity

32

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Test Coverage

Coverage

66.27%

Importance

Changes	2
Bugs	1	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	3	1
A	__construct()	0	6	1
A	getEpsProduction()	0	18	4
A	getWarpdriveProduction()	0	18	3
A	setOutput()	0	5	1
A	getUsage()	0	4	1
A	getOutput()	0	3	1
A	setLoad()	0	5	1
A	changeLoad()	0	5	1
A	getCapacity()	0	3	1
A	isHealthy()	0	3	1
A	getEffectiveWarpDriveProduction()	0	7	2
A	getLoad()	0	3	1
A	getEffectiveEpsProduction()	0	6	2
A	getOutputCappedByLoad()	0	7	2
A	calculateEffectiveProduction()	0	27	5
A	getReactorLoadStyle()	0	16	4

<?php

declare(strict_types=1);

namespace Stu\Module\Ship\Lib;

use Stu\Component\Ship\System\Data\AbstractReactorSystemData;

final class ReactorWrapper implements ReactorWrapperInterface
{
    private ShipWrapperInterface $wrapper;
    private AbstractReactorSystemData $reactorSystemData;

    //absolute values
    private ?int $epsProduction = null;
    private ?int $warpdriveProduction = null;

    //effective values    
    private ?int $effectiveEpsProduction = null;
    private ?int $effectiveWarpDriveProduction = null;

    public function __construct(
        ShipWrapperInterface $wrapper,
        AbstractReactorSystemData $reactorSystemData
    ) {
        $this->wrapper = $wrapper;
        $this->reactorSystemData = $reactorSystemData;
    }

    public function get(): AbstractReactorSystemData
    {
        return $this->reactorSystemData;
    }

    public function getEpsProduction(): int
    {
        if ($this->epsProduction === null) {
            $warpdrive = $this->wrapper->getWarpDriveSystemData();
            $warpdriveSplit = $warpdrive === null ? 100 : $warpdrive->getWarpDriveSplit();
            $reactorOutput = $this->getOutputCappedByLoad();

            if ($warpdriveSplit === 0) {
                $this->epsProduction = min($reactorOutput, $this->wrapper->getEpsUsage());
            } else {
                $warpDriveProduction = $this->getWarpdriveProduction();
                $flightCost = $this->wrapper->get()->getRump()->getFlightEcost();

                $this->epsProduction = $reactorOutput - ($warpDriveProduction * $flightCost);
            }
        }

        return $this->epsProduction;

The expression return $this->epsProduction could return the type null which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    private function getWarpdriveProduction(): int
    {
        if ($this->warpdriveProduction === null) {
            $warpdrive = $this->wrapper->getWarpDriveSystemData();

            if ($warpdrive === null) {
                $this->warpdriveProduction = 0;
            } else {
                $warpdriveSplit = $warpdrive->getWarpDriveSplit();
                $reactorOutput = $this->getOutputCappedByLoad();
                $flightCost = $this->wrapper->get()->getRump()->getFlightEcost();
                $maxWarpdriveGain = max(0, (int)floor(($reactorOutput - $this->wrapper->getEpsUsage()) / $flightCost));

                $this->warpdriveProduction = (int)round((1 - ($warpdriveSplit / 100)) * $maxWarpdriveGain);
            }
        }

        return $this->warpdriveProduction;

The expression return $this->warpdriveProduction could return the type null which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    public function getEffectiveEpsProduction(): int
    {
        if ($this->effectiveEpsProduction === null) {
            $this->calculateEffectiveProduction();
        }
        return $this->effectiveEpsProduction;

The expression return $this->effectiveEpsProduction could return the type null which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    public function getEffectiveWarpDriveProduction(): int
    {
        if ($this->effectiveWarpDriveProduction === null) {
            $this->calculateEffectiveProduction();
        }

        return $this->effectiveWarpDriveProduction;

The expression return $this->effectiveWarpDriveProduction could return the type null which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    private function calculateEffectiveProduction(): void
    {
        $epsSystem = $this->wrapper->getEpsSystemData();
        $warpdrive = $this->wrapper->getWarpDriveSystemData();

        $missingEps = $epsSystem === null ? 0 : $epsSystem->getMaxEps() - $epsSystem->getEps();
        $missingWarpdrive = $warpdrive === null ? 0 : $warpdrive->getMaxWarpDrive() - $warpdrive->getWarpDrive();

        $potential = $this->getOutputCappedByLoad();
        $potential -= $this->wrapper->getEpsUsage();

        $flightCost = $this->wrapper->get()->getRump()->getFlightEcost();

        $epsChange = $this->getEpsProduction() - $this->wrapper->getEpsUsage();
        $effEpsProd = min($missingEps, $epsChange);
        $effWdProd = min($missingWarpdrive, $this->getWarpdriveProduction());

        if ($warpdrive !== null && $warpdrive->getAutoCarryOver()) {
            $excess = max(0, $potential - $effEpsProd - $effWdProd * $flightCost);
            $epsChange = $this->getEpsProduction() + $excess - $this->wrapper->getEpsUsage();

            $effEpsProd = min($missingEps, $epsChange);
            $effWdProd = min($missingWarpdrive, $this->getWarpdriveProduction() + (int)floor($excess / $flightCost));
        }

        $this->effectiveEpsProduction = $effEpsProd;
        $this->effectiveWarpDriveProduction = $effWdProd;
    }

    public function getUsage(): int
    {
        return $this->getEffectiveEpsProduction()
            + $this->getEffectiveWarpDriveProduction() * $this->wrapper->get()->getRump()->getFlightEcost();
    }

    public function getCapacity(): int
    {
        return $this->get()->getCapacity();
    }

    public function getOutput(): int
    {
        return $this->get()->getOutput();
    }

    public function setOutput(int $output): ReactorWrapperInterface
    {
        $this->get()->setOutput($output)->update();

        return $this;
    }

    public function getOutputCappedByLoad(): int
    {
        if ($this->getOutput() > $this->getLoad()) {
            return $this->getLoad();
        }

        return $this->getOutput();
    }

    public function getLoad(): int
    {
        return $this->get()->getLoad();
    }

    public function setLoad(int $load): ReactorWrapperInterface
    {
        $this->get()->setLoad($load)->update();

        return $this;
    }

    public function changeLoad(int $amount): ReactorWrapperInterface
    {
        $this->get()->setLoad($this->get()->getLoad() + $amount)->update();

        return $this;
    }

    public function isHealthy(): bool
    {
        return $this->wrapper->get()->isSystemHealthy($this->get()->getSystemType());
    }

    public function getReactorLoadStyle(): string
    {
        $load = $this->getLoad();
        $output = $this->getOutput();

        if ($load < $output) {
            return "color: red;";
        }

        if ($this->getCapacity() === 0) {
            return "";
        }

        $percentage = $load / $this->getCapacity();

        return $percentage > 0.3 ? "" :  "color: yellow;";
    }
}