Stu\Module\Tick\Spacecraft\ManagerComponent\RepairActions

Complexity

Total Complexity

41

Size/Duplication

Total Lines	251
Duplicated Lines	0 %

Test Coverage

Coverage

0.66%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	work()	0	7	1
A	__construct()	0	1	1
B	repairShipsOnColonies()	0	44	9
A	repairHull()	0	8	3
A	sendPrivateMessages()	0	45	4
A	repairShipsOnStations()	0	13	4
A	repairShipOnEntity()	0	34	4
B	repairShipSystems()	0	39	10
A	proceedSpareParts()	0	31	5

<?php

declare(strict_types=1);

namespace Stu\Module\Tick\Spacecraft\ManagerComponent;

use Override;

The type Override was not found. Maybe you did not declare it correctly or list all dependencies?

use Stu\Component\Building\BuildingFunctionEnum;
use Stu\Component\Colony\ColonyFunctionManagerInterface;
use Stu\Component\Spacecraft\Repair\RepairUtil;
use Stu\Lib\Transfer\Storage\StorageManagerInterface;
use Stu\Component\Spacecraft\Repair\RepairUtilInterface;
use Stu\Component\Spacecraft\SpacecraftStateEnum;
use Stu\Component\Spacecraft\System\SpacecraftSystemManagerInterface;
use Stu\Module\Message\Lib\PrivateMessageFolderTypeEnum;
use Stu\Module\Message\Lib\PrivateMessageSenderInterface;
use Stu\Module\PlayerSetting\Lib\UserConstants;

The type Stu\Module\PlayerSetting\Lib\UserConstants was not found. Maybe you did not declare it correctly or list all dependencies?

use Stu\Module\Spacecraft\Lib\SpacecraftWrapperFactoryInterface;
use Stu\Module\Ship\Lib\ShipWrapperInterface;
use Stu\Orm\Entity\Colony;
use Stu\Orm\Entity\Ship;
use Stu\Orm\Entity\Station;
use Stu\Orm\Repository\ColonyShipRepairRepositoryInterface;
use Stu\Orm\Repository\ModuleQueueRepositoryInterface;
use Stu\Orm\Repository\PlanetFieldRepositoryInterface;
use Stu\Orm\Repository\ShipRepositoryInterface;
use Stu\Orm\Repository\StationShipRepairRepositoryInterface;

final class RepairActions implements ManagerComponentInterface
{
    public function __construct(private ShipRepositoryInterface $shipRepository, private PrivateMessageSenderInterface $privateMessageSender, private SpacecraftSystemManagerInterface $spacecraftSystemManager, private ColonyShipRepairRepositoryInterface $colonyShipRepairRepository, private StationShipRepairRepositoryInterface $stationShipRepairRepository, private StorageManagerInterface $storageManager, private ModuleQueueRepositoryInterface $moduleQueueRepository, private RepairUtilInterface $repairUtil, private SpacecraftWrapperFactoryInterface $spacecraftWrapperFactory, private PlanetFieldRepositoryInterface $planetFieldRepository, private ColonyFunctionManagerInterface $colonyFunctionManager) {}

    #[Override]
    public function work(): void
    {
        //spare parts and system components are generated by spacecraft tick, to avoid dead locks
        $this->proceedSpareParts();
        $this->repairShipsOnColonies(1);
        $this->repairShipsOnStations();
    }

    private function proceedSpareParts(): void
    {
        foreach ($this->moduleQueueRepository->findAll() as $queue) {
            $buildingFunction = $queue->getBuildingFunction();

            if (
                $buildingFunction === BuildingFunctionEnum::FABRICATION_HALL ||
                $buildingFunction === BuildingFunctionEnum::TECH_CENTER
            ) {
                $colony = $queue->getColony();

                if ($this->colonyFunctionManager->hasActiveFunction($colony, $buildingFunction)) {
                    $this->storageManager->upperStorage(
                        $colony,
                        $queue->getModule()->getCommodity(),
                        $queue->getAmount()
                    );

                    $this->privateMessageSender->send(
                        UserConstants::USER_NOONE,
                        $colony->getUser()->getId(),
                        sprintf(
                            "Tickreport der Kolonie %s\nEs wurden %d %s hergestellt",
                            $colony->getName(),
                            $queue->getAmount(),
                            $queue->getModule()->getName()
                        ),
                        PrivateMessageFolderTypeEnum::SPECIAL_COLONY
                    );

                    $this->moduleQueueRepository->delete($queue);
                }
            }
        }
    }

    private function repairShipsOnColonies(int $tickId): void
    {
        $usedShipyards = [];

        foreach ($this->colonyShipRepairRepository->getMostRecentJobs($tickId) as $obj) {
            $ship = $obj->getShip();
            $colony = $obj->getColony();

            if ($colony->isBlocked()) {
                continue;
            }

            $field = $this->planetFieldRepository->getByColonyAndFieldIndex(
                $obj->getColonyId(),
                $obj->getFieldId()
            );

            if ($field === null) {
                continue;
            }

            if (!$field->isActive()) {
                continue;
            }

            if (!array_key_exists($colony->getId(), $usedShipyards)) {
                $usedShipyards[$colony->getId()] = [];
            }

            $isRepairStationBonus = $this->colonyFunctionManager->hasActiveFunction($colony, BuildingFunctionEnum::REPAIR_SHIPYARD);

            //already repaired a ship on this colony field, max is one without repair station
            if (
                !$isRepairStationBonus
                && array_key_exists($field->getFieldId(), $usedShipyards[$colony->getId()])
            ) {
                continue;
            }

            $usedShipyards[$colony->getId()][$field->getFieldId()] = [$field->getFieldId()];

            if ($this->repairShipOnEntity($ship, $colony, $isRepairStationBonus)) {
                $this->colonyShipRepairRepository->delete($obj);
                $this->shipRepository->save($ship);
            }
        }
    }

    private function repairShipsOnStations(): 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(Ship $ship, Colony|Station $entity, bool $isRepairStationBonus): bool
    {
        // check for U-Mode
        if ($entity->getUser()->isVacationRequestOldEnough()) {
            return false;
        }

        $wrapper = $this->spacecraftWrapperFactory->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->getCondition()->setHull($ship->getMaxHull());
            $ship->getCondition()->setState(SpacecraftStateEnum::NONE);

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

        return $repairFinished;
    }

    private function repairHull(Ship $ship, bool $isRepairStationBonus): void
    {
        $condition = $ship->getCondition();
        $hullRepairRate = $isRepairStationBonus ? RepairUtil::REPAIR_RATE_PER_TICK * 2 : RepairUtil::REPAIR_RATE_PER_TICK;

        $condition->changeHull($hullRepairRate);
        if ($condition->getHull() > $ship->getMaxHull()) {
            $condition->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->spacecraftSystemManager->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->spacecraftSystemManager->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->spacecraftSystemManager->lookupSystem($thirdSystem->getSystemType())->getDefaultMode());
                    }
                }
                if (count($damagedSystems) > 3) {
                    $fourthSystem = $damagedSystems[3];
                    $fourthSystem->setStatus(100);

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

    private function sendPrivateMessages(Ship $ship, Colony|Station $entity): void
    {
        $shipOwnerMessage = $entity instanceof Colony ? 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 Colony ? 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(
            UserConstants::USER_NOONE,
            $entity->getUser()->getId(),
            $entityOwnerMessage,
            $entity instanceof Colony ? PrivateMessageFolderTypeEnum::SPECIAL_COLONY :
                PrivateMessageFolderTypeEnum::SPECIAL_STATION
        );
    }
}