RepairActions::__construct() - Code Metrics - Inspection of "introduce event scheduling and entity locks" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — dev ( eeaa0f...91a85a )

by Janko
created 2024-08-12 06:13 UTC
RepairActions::__construct() A

↳ Parent: RepairActions
Complexity

Conditions	1
Paths	1
Size

Total Lines	10
Code Lines	0
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
cc	1
eloc	0
nc	1
nop	8
dl	0
loc	10
ccs	0
cts	1
cp	0
crap	2
rs	10
c	0
b	0
f	0
How to fix Many Parameters

<?php

declare(strict_types=1);

namespace Stu\Module\Tick\Ship\ManagerComponent;

use Stu\Component\Building\BuildingEnum;
filter:
    dependency_paths: ["lib/*"]
use Stu\Component\Colony\ColonyFunctionManagerInterface;
use Stu\Component\Ship\Repair\RepairUtilInterface;
use Stu\Component\Ship\ShipStateEnum;
use Stu\Component\Ship\System\ShipSystemManagerInterface;
use Stu\Module\Message\Lib\PrivateMessageFolderTypeEnum;
use Stu\Module\Message\Lib\PrivateMessageSenderInterface;
use Stu\Module\PlayerSetting\Lib\UserEnum;
filter:
    dependency_paths: ["lib/*"]
use Stu\Module\Ship\Lib\ShipWrapperFactoryInterface;
use Stu\Module\Ship\Lib\ShipWrapperInterface;
use Stu\Orm\Entity\ColonyInterface;
use Stu\Orm\Entity\ColonyShipRepairInterface;
use Stu\Orm\Entity\ShipInterface;
use Stu\Orm\Entity\StationShipRepairInterface;
use Stu\Orm\Repository\ColonyShipRepairRepositoryInterface;
use Stu\Orm\Repository\ShipRepositoryInterface;
use Stu\Orm\Repository\StationShipRepairRepositoryInterface;

final class RepairActions
{
    public function __construct(
        private ShipRepositoryInterface $shipRepository,
        private PrivateMessageSenderInterface $privateMessageSender,
        private ShipSystemManagerInterface $shipSystemManager,
        private ColonyShipRepairRepositoryInterface $colonyShipRepairRepository,
        private StationShipRepairRepositoryInterface $stationShipRepairRepository,
        private RepairUtilInterface $repairUtil,
        private ShipWrapperFactoryInterface $shipWrapperFactory,
        private ColonyFunctionManagerInterface $colonyFunctionManager
    ) {
    }

    public function repairShipOnColony(ColonyShipRepairInterface $colonyShipRepair): void
    {
        $ship = $colonyShipRepair->getShip();
        $colony = $colonyShipRepair->getColony();

        $isRepairStationBonus = $this->colonyFunctionManager->hasActiveFunction($colony, BuildingEnum::BUILDING_FUNCTION_REPAIR_SHIPYARD);
        if ($this->repairShipOnEntity($ship, $colony, $isRepairStationBonus)) {
            $this->colonyShipRepairRepository->delete($colonyShipRepair);
            $this->shipRepository->save($ship);
        }
    }

    public function repairShipOnStation(StationShipRepairInterface $stationShipRepair): void
    public function repairShipOnStation(/** @scrutinizer ignore-unused */ StationShipRepairInterface $stationShipRepair): void
    {
        foreach ($this->stationShipRepairRepository->getMostRecentJobs() as $obj) {
            $ship = $obj->getShip();
            $station = $obj->getStation();

            if (!$station->hasEnoughCrew()) {
                continue;
            }

            if ($this->repairShipOnEntity($ship, $station, false)) {
                $this->stationShipRepairRepository->delete($obj);
                $this->shipRepository->save($ship);
            }
        }
    }

    private function repairShipOnEntity(ShipInterface $ship, ColonyInterface|ShipInterface $entity, bool $isRepairStationBonus): bool
    {
        // check for U-Mode
        if ($entity->getUser()->isVacationRequestOldEnough()) {
            return false;
        }

        $wrapper = $this->shipWrapperFactory->wrapShip($ship);
        $neededParts = $this->repairUtil->determineSpareParts($wrapper, true);

        // parts stored?
        if (!$this->repairUtil->enoughSparePartsOnEntity($neededParts, $entity, $ship)) {
            return false;
        }

        $repairFinished = false;

        $this->repairHull($ship, $isRepairStationBonus);
        $this->repairShipSystems($wrapper, $isRepairStationBonus);

        // consume spare parts
        $this->repairUtil->consumeSpareParts($neededParts, $entity);

        if (!$wrapper->canBeRepaired()) {
            $repairFinished = true;

            $ship->setHull($ship->getMaxHull());
            $ship->setState(ShipStateEnum::SHIP_STATE_NONE);

            $this->sendPrivateMessages($ship, $entity);
        }
        $this->shipRepository->save($ship);

        return $repairFinished;
    }

    private function repairHull(ShipInterface $ship, bool $isRepairStationBonus): void
    {
        $hullRepairRate = $isRepairStationBonus ? $ship->getRepairRate() * 2 : $ship->getRepairRate();
        $ship->setHull($ship->getHull() + $hullRepairRate);
        if ($ship->getHull() > $ship->getMaxHull()) {
            $ship->setHull($ship->getMaxHull());
        }
    }

    private function repairShipSystems(ShipWrapperInterface $wrapper, bool $isRepairStationBonus): void
    {
        $ship = $wrapper->get();

        $damagedSystems = $wrapper->getDamagedSystems();
        if ($damagedSystems !== []) {
            $firstSystem = $damagedSystems[0];
            $firstSystem->setStatus(100);

            if ($ship->getCrewCount() > 0) {
                $firstSystem->setMode($this->shipSystemManager->lookupSystem($firstSystem->getSystemType())->getDefaultMode());
            }

            // maximum of two systems get repaired
            if (count($damagedSystems) > 1) {
                $secondSystem = $damagedSystems[1];
                $secondSystem->setStatus(100);

                if ($ship->getCrewCount() > 0) {
                    $secondSystem->setMode($this->shipSystemManager->lookupSystem($secondSystem->getSystemType())->getDefaultMode());
                }
            }

            // maximum of two additional systems get repaired
            if ($isRepairStationBonus) {
                if (count($damagedSystems) > 2) {
                    $thirdSystem = $damagedSystems[2];
                    $thirdSystem->setStatus(100);

                    if ($ship->getCrewCount() > 0) {
                        $thirdSystem->setMode($this->shipSystemManager->lookupSystem($thirdSystem->getSystemType())->getDefaultMode());
                    }
                }
                if (count($damagedSystems) > 3) {
                    $fourthSystem = $damagedSystems[3];
                    $fourthSystem->setStatus(100);

                    if ($ship->getCrewCount() > 0) {
                        $fourthSystem->setMode($this->shipSystemManager->lookupSystem($fourthSystem->getSystemType())->getDefaultMode());
                    }
                }
            }
        }
    }

    private function sendPrivateMessages(ShipInterface $ship, ColonyInterface|ShipInterface $entity): void
    {
        $shipOwnerMessage = $entity instanceof ColonyInterface ? sprintf(
            "Die Reparatur der %s wurde in Sektor %s bei der Kolonie %s des Spielers %s fertiggestellt",
            $ship->getName(),
            $ship->getSectorString(),
            $entity->getName(),
            $entity->getUser()->getName()
        ) : sprintf(
            "Die Reparatur der %s wurde in Sektor %s von der %s %s des Spielers %s fertiggestellt",
            $ship->getName(),
            $ship->getSectorString(),
            $entity->getRump()->getName(),
            $entity->getName(),
            $entity->getUser()->getName()
        );

        $this->privateMessageSender->send(
            $entity->getUser()->getId(),
            $ship->getUser()->getId(),
            $shipOwnerMessage,
            PrivateMessageFolderTypeEnum::SPECIAL_SHIP
        );

        $entityOwnerMessage = $entity instanceof ColonyInterface ? sprintf(
            "Die Reparatur der %s von Siedler %s wurde in Sektor %s bei der Kolonie %s fertiggestellt",
            $ship->getName(),
            $ship->getUser()->getName(),
            $ship->getSectorString(),
            $entity->getName()
        ) : sprintf(
            "Die Reparatur der %s von Siedler %s wurde in Sektor %s von der %s %s fertiggestellt",
            $ship->getName(),
            $ship->getUser()->getName(),
            $ship->getSectorString(),
            $entity->getRump()->getName(),
            $entity->getName()
        );

        $this->privateMessageSender->send(
            UserEnum::USER_NOONE,
            $entity->getUser()->getId(),
            $entityOwnerMessage,
            $entity instanceof ColonyInterface ? PrivateMessageFolderTypeEnum::SPECIAL_COLONY :
                PrivateMessageFolderTypeEnum::SPECIAL_STATION
        );
    }
}

st-universe / core

Push — dev ( eeaa0f...91a85a )

RepairActions::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like
