ColonyTick::__construct() - Code Metrics - Inspection of "added commodity cache" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — dev ( 766009...bcc49c )

by Janko
created 2023-06-15 10:06 UTC
ColonyTick::__construct() A

↳ Parent: ColonyTick
Complexity

Conditions	1
Paths	1
Size

Total Lines	30
Code Lines	14
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	14
nc	1
nop	14
dl	0
loc	30
ccs	0
cts	15
cp	0
crap	2
rs	9.7998
c	1
b	0
f	0
How to fix Many Parameters

<?php

namespace Stu\Module\Tick\Colony;

use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\EntityManagerInterface;
use InvalidArgumentException;
use RuntimeException;
use Stu\Component\Building\BuildingEnum;
use Stu\Component\Building\BuildingManagerInterface;
use Stu\Component\Colony\ColonyFunctionManagerInterface;
use Stu\Component\Colony\Storage\ColonyStorageManagerInterface;
use Stu\Lib\ColonyProduction\ColonyProduction;
use Stu\Module\Colony\Lib\ColonyLibFactoryInterface;
use Stu\Module\Commodity\Lib\CommodityCacheInterface;
use Stu\Module\Logging\LoggerUtilFactoryInterface;
use Stu\Module\Logging\LoggerUtilInterface;
use Stu\Module\Message\Lib\PrivateMessageFolderSpecialEnum;
use Stu\Module\Message\Lib\PrivateMessageSenderInterface;
use Stu\Module\PlayerSetting\Lib\UserEnum;
use Stu\Module\Research\ResearchStateFactoryInterface;
use Stu\Orm\Entity\BuildingCommodityInterface;
use Stu\Orm\Entity\ColonyInterface;
use Stu\Orm\Entity\CommodityInterface;
use Stu\Orm\Entity\PlanetFieldInterface;
use Stu\Orm\Repository\ColonyDepositMiningRepositoryInterface;
use Stu\Orm\Repository\ColonyRepositoryInterface;
use Stu\Orm\Repository\ModuleQueueRepositoryInterface;
use Stu\Orm\Repository\PlanetFieldRepositoryInterface;
use Stu\Orm\Repository\ResearchedRepositoryInterface;

final class ColonyTick implements ColonyTickInterface
{
    private ResearchedRepositoryInterface $researchedRepository;

    private ModuleQueueRepositoryInterface $moduleQueueRepository;

    private PlanetFieldRepositoryInterface $planetFieldRepository;

    private PrivateMessageSenderInterface $privateMessageSender;

    private ColonyStorageManagerInterface $colonyStorageManager;

    private ColonyRepositoryInterface $colonyRepository;

    private BuildingManagerInterface $buildingManager;

    private ColonyDepositMiningRepositoryInterface $colonyDepositMiningRepository;

    private EntityManagerInterface $entityManager;

    private ColonyLibFactoryInterface $colonyLibFactory;

    private ColonyFunctionManagerInterface $colonyFunctionManager;

    private ResearchStateFactoryInterface $researchStateFactory;

    private CommodityCacheInterface $commodityCache;

    private LoggerUtilInterface $loggerUtil;

    /**
     * @var array<string>
     */
    private array $msg = [];

    public function __construct(
        ResearchedRepositoryInterface $researchedRepository,
        ModuleQueueRepositoryInterface $moduleQueueRepository,
        PlanetFieldRepositoryInterface $planetFieldRepository,
        PrivateMessageSenderInterface $privateMessageSender,
        ColonyStorageManagerInterface $colonyStorageManager,
        ColonyRepositoryInterface $colonyRepository,
        BuildingManagerInterface $buildingManager,
        ColonyDepositMiningRepositoryInterface $colonyDepositMiningRepository,
        EntityManagerInterface $entityManager,
        ColonyLibFactoryInterface $colonyLibFactory,
        ColonyFunctionManagerInterface $colonyFunctionManager,
        ResearchStateFactoryInterface $researchStateFactory,
        CommodityCacheInterface $commodityCache,
        LoggerUtilFactoryInterface $loggerUtilFactory
    ) {
        $this->researchedRepository = $researchedRepository;
        $this->moduleQueueRepository = $moduleQueueRepository;
        $this->planetFieldRepository = $planetFieldRepository;
        $this->privateMessageSender = $privateMessageSender;
        $this->colonyStorageManager = $colonyStorageManager;
        $this->colonyRepository = $colonyRepository;
        $this->buildingManager = $buildingManager;
        $this->colonyDepositMiningRepository = $colonyDepositMiningRepository;
        $this->entityManager = $entityManager;
        $this->colonyLibFactory = $colonyLibFactory;
        $this->colonyFunctionManager = $colonyFunctionManager;
        $this->researchStateFactory = $researchStateFactory;
        $this->commodityCache = $commodityCache;
        $this->loggerUtil = $loggerUtilFactory->getLoggerUtil();
    }

    public function work(ColonyInterface $colony): void
    {
        $doLog = $this->loggerUtil->doLog();
        if ($doLog) {
            $startTime = microtime(true);
        }

        $this->mainLoop($colony);

        $this->colonyRepository->save($colony);

        $this->proceedModules($colony);
        $this->sendMessages($colony);

        if ($doLog) {
            $endTime = microtime(true);
            $this->loggerUtil->log(sprintf("Colony-Id: %6d, seconds: %F", $colony->getId(), $endTime - $startTime));

        }
    }

    private function mainLoop(ColonyInterface $colony): void
    {
        $doLog = $this->loggerUtil->doLog();

        if ($doLog) {
            $startTime = microtime(true);
        }

        $i = 1;
        $production = $this->colonyLibFactory->createColonyCommodityProduction($colony)->getProduction();

        while (true) {

            $rewind = $this->checkStorage($colony, $production);
            $rewind |= $this->checkLivingSpace($colony, $production);
            $rewind |= $this->checkEnergyProduction($colony, $production);

            if ($rewind) {
                $i++;
                if ($i == 100) {
                    // SECURITY
                    //echo "HIT SECURITY BREAK\n";
                    break;
                }
                continue;
            }
            break;
        }
        $colony->setEps(
            min(
                $colony->getMaxEps(),
                $colony->getEps() + $this->planetFieldRepository->getEnergyProductionByColony($colony->getId())
            )
        );

        if ($doLog) {
            $endTime = microtime(true);
            $this->loggerUtil->log(sprintf("\tmainLoop, seconds: %F", $endTime - $startTime));

        }

        $this->proceedStorage($colony, $production);
    }

    /**
     * @param array<int, ColonyProduction> $production
     */
    private function checkStorage(
        ColonyInterface $colony,
        array &$production
    ): bool {

        $result = false;

        foreach ($production as $pro) {
            if ($pro->getProduction() >= 0) {
                continue;
            }

            $commodityId = $pro->getCommodityId();

            $depositMining = $colony->getUserDepositMinings()[$commodityId] ?? null;
            if ($depositMining !== null) {
                if ($depositMining->isEnoughLeft((int) abs($pro->getProduction()))) {
                    continue;
                }
            }

            $storage = $colony->getStorage();
            $storageItem = $storage[$commodityId] ?? null;
            if ($storageItem !== null && $storageItem->getAmount() + $pro->getProduction() >= 0) {
                continue;
            }
            //echo "coloId:" . $colony->getId() . ", production:" . $pro->getProduction() . ", commodityId:" . $commodityId . ", commodity:" . $this->commodityCache->get($commodityId)->getName() . "\n";
            $field = $this->getBuildingToDeactivateByCommodity($colony, $commodityId);
            // echo $i." hit by commodity ".$field->getFieldId()." - produce ".$pro->getProduction()." MT ".microtime()."\n";
            $this->deactivateBuilding($field, $production, $this->commodityCache->get($commodityId));

            $result = true;
        }

        return $result;
    }

    /**
     * @param array<int, ColonyProduction> $production
     */
    private function checkLivingSpace(ColonyInterface $colony, array &$production): bool
    {
        if ($colony->getWorkers() > $colony->getMaxBev()) {
            $field = $this->getBuildingToDeactivateByLivingSpace($colony);
            if ($field !== null) {
                $this->deactivateBuilding($field, $production, 'Wohnraum');

                return true;
            }
        }

        return false;
    }

    /**
     * @param array<int, ColonyProduction> $production
     */
    private function checkEnergyProduction(ColonyInterface $colony, array &$production): bool
    {
        $energyProduction = $this->planetFieldRepository->getEnergyProductionByColony($colony->getId());

        if ($energyProduction < 0 && $colony->getEps() + $energyProduction < 0) {
            $field = $this->getBuildingToDeactivateByEpsUsage($colony);
            //echo $i . " hit by eps " . $field->getFieldId() . " - complete usage " . $colony->getEpsProduction() . " - usage " . $field->getBuilding()->getEpsProduction() . " MT " . microtime() . "\n";
            $this->deactivateBuilding($field, $production, 'Energie');

            return true;
        }

        return false;
    }

    /**
     * @param array<ColonyProduction> $production
     */
    private function deactivateBuilding(
        PlanetFieldInterface $field,
        array &$production,
        CommodityInterface|string $cause
    ): void {
        if ($cause instanceof CommodityInterface) {
            $ext = $cause->getName();
        } else {
            $ext = $cause;
        }
        $building = $field->getBuilding();

        if ($building === null) {
            throw new InvalidArgumentException('can not deactivate field without building');
        }

        $this->buildingManager->deactivate($field);
        $this->entityManager->flush();

        $this->mergeProduction($building->getCommodities(), $production);

        $this->msg[] = $building->getName() . " auf Feld " . $field->getFieldId() . " deaktiviert (Mangel an " . $ext . ")";
    }

    private function getBuildingToDeactivateByCommodity(ColonyInterface $colony, int $commodityId): PlanetFieldInterface
    {
        $fields = $this->planetFieldRepository->getCommodityConsumingByColonyAndCommodity(
            $colony->getId(),
            $commodityId,
            [1]
        );

        $result = current($fields);
        $result = current(/** @scrutinizer ignore-type */ $fields);
        if (!$result) {
            throw new RuntimeException('no building found');
        }

        return $result;
    }

    private function getBuildingToDeactivateByEpsUsage(ColonyInterface $colony): PlanetFieldInterface
    {
        $fields = $this->planetFieldRepository->getEnergyConsumingByColony($colony->getId(), [1], 1);

        $result = current($fields);
        $result = current(/** @scrutinizer ignore-type */ $fields);
        if (!$result) {
            throw new RuntimeException('no building found');
        }

        return $result;
    }

    private function getBuildingToDeactivateByLivingSpace(ColonyInterface $colony): ?PlanetFieldInterface
    {
        $fields = $this->planetFieldRepository->getWorkerConsumingByColonyAndState($colony->getId(), [1], 1);

        return empty($fields) ? null : current($fields);
        return empty($fields) ? null : current(/** @scrutinizer ignore-type */ $fields);
    }

    /**
     * @param array<ColonyProduction> $production
     */
    private function proceedStorage(
        ColonyInterface $colony,
        array $production
    ): void {
        $doLog = $this->loggerUtil->doLog();
        if ($doLog) {
            $startTime = microtime(true);
        }

        $sum = $colony->getStorageSum();

        if ($doLog) {
            $startTime = microtime(true);
        }

        //DECREASE
        foreach ($production as $commodityId => $obj) {
            $amount = $obj->getProduction();
            $commodity = $this->commodityCache->get($commodityId);

            if ($amount < 0) {
                $amount = (int) abs($amount);

                if ($commodity->isSaveable()) {
                    // STANDARD
                    $this->colonyStorageManager->lowerStorage(
                        $colony,
                        $this->commodityCache->get($commodityId),
                        $amount
                    );
                    $sum -= $amount;
                } else {
                    // EFFECTS
                    $depositMining = $colony->getUserDepositMinings()[$commodityId];

                    $depositMining->setAmountLeft($depositMining->getAmountLeft() - $amount);
                    $this->colonyDepositMiningRepository->save($depositMining);
                }
            }
        }
        if ($doLog) {
            $endTime = microtime(true);
            $this->loggerUtil->log(sprintf("\tforeach1, seconds: %F", $endTime - $startTime));

        }

        if ($doLog) {
            $startTime = microtime(true);
        }
        foreach ($production as $commodityId => $obj) {
            $startTimeC = microtime(true);

            $commodity = $this->commodityCache->get($commodityId);
            if ($obj->getProduction() <= 0 || !$commodity->isSaveable()) {
                continue;
            }
            if ($sum >= $colony->getMaxStorage()) {
                if ($colony->getUser()->isStorageNotification()) {
                    $this->msg[] = _('Das Lager der Kolonie ist voll');
                }
                break;
            }
            if ($sum + $obj->getProduction() > $colony->getMaxStorage()) {
                $this->colonyStorageManager->upperStorage(
                    $colony,
                    $commodity,
                    $colony->getMaxStorage() - $sum
                );
                if ($colony->getUser()->isStorageNotification()) {
                    $this->msg[] = _('Das Lager der Kolonie ist voll');
                }
                break;
            }
            $startTimeM = microtime(true);
            $this->colonyStorageManager->upperStorage(
                $colony,
                $commodity,
                $obj->getProduction()
            );
            if ($doLog) {
                $endTimeM = microtime(true);
                $this->loggerUtil->log(sprintf("\t\t\tupper, seconds: %F", $endTimeM - $startTimeM));
            }
            $sum += $obj->getProduction();
            if ($doLog) {
                $endTimeC = microtime(true);
                $this->loggerUtil->log(sprintf("\t\tcommodity: %s, seconds: %F", $commodity->getName(), $endTimeC - $startTimeC));
            }
        }
        if ($doLog) {
            $endTime = microtime(true);
            $this->loggerUtil->log(sprintf("\tforeach2, seconds: %F", $endTime - $startTime));
        }

        if ($doLog) {
            $startTime = microtime(true);
        }
        $current_research = $this->researchedRepository->getCurrentResearch($colony->getUser());

        if ($current_research && $current_research->getActive()) {
            if (isset($production[$current_research->getResearch()->getCommodityId()])) {
                $this->researchStateFactory->createResearchState()->advance(
                    $current_research,
                    $production[$current_research->getResearch()->getCommodityId()]->getProduction()
                );
            }
        }
        if ($doLog) {
            $endTime = microtime(true);
            $this->loggerUtil->log(sprintf("\tresearch, seconds: %F", $endTime - $startTime));
        }

        if ($colony->getPopulation() > $colony->getMaxBev()) {
            $this->proceedEmigration($colony);
            return;
        }

        if ($colony->getPopulationLimit() > 0 && $colony->getPopulation() > $colony->getPopulationLimit() && $colony->getWorkless()) {
            if (($free = ($colony->getPopulationLimit() - $colony->getWorkers())) > 0) {
                $this->msg[] = sprintf(
                    _('Es sind %d Arbeitslose ausgewandert'),
                    ($colony->getWorkless() - $free)
                );
                $colony->setWorkless($free);
            } else {
                $this->msg[] = _('Es sind alle Arbeitslosen ausgewandert');
                $colony->setWorkless(0);
            }
        }
        $this->proceedImmigration(
            $colony,
            $production
        );

        if ($doLog) {
            $endTime = microtime(true);
            $this->loggerUtil->log(sprintf("\tstorage, seconds: %F", $endTime - $startTime));
        }
    }

    private function proceedModules(ColonyInterface $colony): void
    {
        foreach ($this->moduleQueueRepository->getByColony((int) $colony->getId()) as $queue) {
            $buildingFunction = $queue->getBuildingFunction();

            //spare parts and system components are generated by ship tick manager, to avoid dead locks
            if (
                $buildingFunction === BuildingEnum::BUILDING_FUNCTION_FABRICATION_HALL ||
                $buildingFunction === BuildingEnum::BUILDING_FUNCTION_TECH_CENTER
            ) {
                continue;
            }

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

                $this->msg[] = sprintf(
                    _('Es wurden %d %s hergestellt'),
                    $queue->getAmount(),
                    $queue->getModule()->getName()
                );
                $this->moduleQueueRepository->delete($queue);
            }
        }
    }

    /**
     * @param array<int, ColonyProduction> $production
     */
    private function proceedImmigration(
        ColonyInterface $colony,
        array $production
    ): void {
        // @todo
        $colony->setWorkless(
            $colony->getWorkless() +
                $this->colonyLibFactory->createColonyPopulationCalculator($colony, $production)->getGrowth()
        );
    }

    private function proceedEmigration(ColonyInterface $colony): void
    {
        if ($colony->getWorkless()) {
            $bev = rand(1, $colony->getWorkless());
            $colony->setWorkless($colony->getWorkless() - $bev);
            $this->msg[] = $bev . " Einwohner sind ausgewandert";
        }
    }

    private function sendMessages(ColonyInterface $colony): void
    {
        if ($this->msg === []) {
            return;
        }
        $text = "Tickreport der Kolonie " . $colony->getName() . "\n";
        foreach ($this->msg as $msg) {
            $text .= $msg . "\n";
        }

        $href = sprintf(_('colony.php?SHOW_COLONY=1&id=%d'), $colony->getId());

        $this->privateMessageSender->send(
            UserEnum::USER_NOONE,
            (int) $colony->getUserId(),
            $text,
            PrivateMessageFolderSpecialEnum::PM_SPECIAL_COLONY,
            $href
        );

        $this->msg = [];
    }

    /**
     * @param Collection<int, BuildingCommodityInterface> $buildingProduction
     * @param array<ColonyProduction> $production
     */
    private function mergeProduction(
        Collection $buildingProduction,
        array &$production
    ): void {
        foreach ($buildingProduction as $obj) {
            $commodityId = $obj->getCommodityId();
            if (!array_key_exists($commodityId, $production)) {
                $data = $this->colonyLibFactory->createColonyProduction(
                    $obj->getCommodity(),
                    $obj->getAmount() * -1
                );

                $production[$commodityId] = $data;
            } else {
                if ($obj->getAmount() < 0) {
                    $production[$commodityId]->upperProduction(abs($obj->getAmount()));
                    $production[$commodityId]->upperProduction(/** @scrutinizer ignore-type */ abs($obj->getAmount()));
                } else {
                    $production[$commodityId]->lowerProduction($obj->getAmount());
                }
            }
        }
    }
}

st-universe / core

Push — dev ( 766009...bcc49c )

ColonyTick::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like
