ShipTickManager::getLoggerUtil() - Code Metrics - Inspection of "next entity fix" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — dev ( ac26ef...6b8aca )

by Nico

created 2023-08-02 15:45 UTC

ShipTickManager::getLoggerUtil() A

↳ Parent: ShipTickManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
ccs	0
cts	2
cp	0
crap	2
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Stu\Module\Tick\Ship;

use Stu\Component\Anomaly\AnomalyHandlingInterface;
use Stu\Module\Colony\Lib\ColonyLibFactoryInterface;
use Stu\Module\History\Lib\EntryCreatorInterface;
use Stu\Module\Logging\LoggerEnum;
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\Ship\Lib\ShipRemoverInterface;
use Stu\Module\Ship\Lib\ShipWrapperFactoryInterface;
use Stu\Module\Tick\AbstractTickManager;
use Stu\Module\Tick\Ship\Crew\CrewLimitationsInterface;
use Stu\Module\Tick\Ship\Repair\RepairActionsInterface;
use Stu\Orm\Entity\ColonyInterface;
use Stu\Orm\Entity\ShipInterface;
use Stu\Orm\Repository\ShipCrewRepositoryInterface;
use Stu\Orm\Repository\ShipRepositoryInterface;
use Stu\Orm\Repository\TradePostRepositoryInterface;
use Ubench;

final class ShipTickManager extends AbstractTickManager implements ShipTickManagerInterface
{
    private CrewLimitationsInterface $crewLimitations;

    private PrivateMessageSenderInterface $privateMessageSender;

    private ShipRemoverInterface $shipRemover;

    private ShipTickInterface $shipTick;

    private ShipRepositoryInterface $shipRepository;

    private ShipCrewRepositoryInterface $shipCrewRepository;

    private TradePostRepositoryInterface $tradePostRepository;

    private ShipWrapperFactoryInterface $shipWrapperFactory;

    private EntryCreatorInterface $entryCreator;

    private ColonyLibFactoryInterface $colonyLibFactory;

    private RepairActionsInterface $repairActions;

    private AnomalyHandlingInterface $anomalyHandling;

    private LoggerUtilInterface $loggerUtil;

    private Ubench $benchmark;

    public function __construct(
        CrewLimitationsInterface $crewLimitations,
        PrivateMessageSenderInterface $privateMessageSender,
        ShipRemoverInterface $shipRemover,
        ShipTickInterface $shipTick,
        ShipRepositoryInterface $shipRepository,
        ShipCrewRepositoryInterface $shipCrewRepository,
        TradePostRepositoryInterface $tradePostRepository,
        ShipWrapperFactoryInterface $shipWrapperFactory,
        EntryCreatorInterface $entryCreator,
        ColonyLibFactoryInterface $colonyLibFactory,
        RepairActionsInterface $repairActions,
        AnomalyHandlingInterface $anomalyHandling,
        LoggerUtilFactoryInterface $loggerUtilFactory,
        Ubench $benchmark
    ) {
        $this->crewLimitations = $crewLimitations;
        $this->privateMessageSender = $privateMessageSender;
        $this->shipRemover = $shipRemover;
        $this->shipTick = $shipTick;
        $this->shipRepository = $shipRepository;
        $this->shipCrewRepository = $shipCrewRepository;
        $this->tradePostRepository = $tradePostRepository;
        $this->shipWrapperFactory = $shipWrapperFactory;
        $this->entryCreator = $entryCreator;
        $this->colonyLibFactory = $colonyLibFactory;
        $this->repairActions = $repairActions;
        $this->anomalyHandling = $anomalyHandling;
        $this->loggerUtil = $loggerUtilFactory->getLoggerUtil();
        $this->benchmark = $benchmark;
    }

    public function work(): void
    {
        $this->anomalyHandling->processExistingAnomalies();
        $this->crewLimitations->work();

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

        $startTime = microtime(true);
        $entityCount = 0;
        foreach ($this->shipRepository->getPlayerShipsForTick() as $ship) {
            //echo "Processing Ship ".$ship->getId()." at ".microtime()."\n";

            $this->shipTick->work($this->shipWrapperFactory->wrapShip($ship));
            $entityCount++;
        }
        if ($this->loggerUtil->doLog()) {
            $endTime = microtime(true);
            $this->loggerUtil->log(sprintf("\t\tshipTick, seconds: %F", $endTime - $startTime));
        }

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

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

        $this->loggerUtil->init('SHIPTICK', LoggerEnum::LEVEL_WARNING);
        $this->logBenchmarkResult($entityCount);

        $this->anomalyHandling->createNewAnomalies();
    }

    private function handleEscapePods(): void
    {
        $escapedToColonies = [];

        foreach ($this->shipRepository->getEscapePods() as $escapePod) {
            if ($escapePod->getCrewCount() === 0) {
                $this->shipRemover->remove($escapePod);
            }

            if ($escapePod->getStarsystemMap() !== null) {
                $colony = $escapePod->getStarsystemMap()->getColony();

                if ($colony !== null) {
                    $count = $this->transferOwnCrewToColony($escapePod, $colony);

                    if ($count > 0) {
                        if (array_key_exists($colony->getId(), $escapedToColonies)) {
                            $oldCount = $escapedToColonies[$colony->getId()][1];

                            $escapedToColonies[$colony->getId()][1] = $oldCount +  $count;
                        } else {
                            $escapedToColonies[$colony->getId()] = [$colony, $count];
                        }
                    }
                }
            }
        }

        foreach ($escapedToColonies as [$colony, $count]) {
            $msg = sprintf(_('%d deiner Crewman sind aus Fluchtkapseln auf deiner Kolonie %s gelandet'), $count, $colony->getName());
            $this->privateMessageSender->send(
                UserEnum::USER_NOONE,
                $colony->getUser()->getId(),
                $msg,
                PrivateMessageFolderSpecialEnum::PM_SPECIAL_COLONY
            );
        }
    }

    private function transferOwnCrewToColony(ShipInterface $escapePod, ColonyInterface $colony): int
    {
        $count = 0;

        foreach ($escapePod->getCrewlist() as $crewAssignment) {
            if ($crewAssignment->getUser() !== $colony->getUser()) {
                continue;
            }

            $freeAssignmentCount = $this->colonyLibFactory->createColonyPopulationCalculator(
                $colony
            )->getFreeAssignmentCount();

            if ($freeAssignmentCount === 0) {
                break;
            }

            $count++;
            $crewAssignment->setShip(null);
            $crewAssignment->setSlot(null);
            $crewAssignment->setColony($colony);
            $escapePod->getCrewlist()->removeElement($crewAssignment);
            $colony->getCrewAssignments()->add($crewAssignment);
            $this->shipCrewRepository->save($crewAssignment);
        }

        return $count;
    }

    private function lowerTrumfieldHull(): void
    {
        foreach ($this->shipRepository->getDebrisFields() as $ship) {
            $lower = random_int(5, 15);
            if ($ship->getHull() <= $lower) {
                $this->shipRemover->remove($ship);
                continue;
            }
            $ship->setHuell($ship->getHull() - $lower);

            $this->shipRepository->save($ship);
        }
    }

    private function lowerOrphanizedTradepostHull(): void
    {
        foreach ($this->tradePostRepository->getByUser(UserEnum::USER_NOONE) as $tradepost) {
            $ship = $tradepost->getShip();

            $lower = (int)ceil($ship->getMaxHull() / 100);

            if ($ship->getHull() <= $lower) {
                $this->shipRemover->destroy($this->shipWrapperFactory->wrapShip($ship));

                $this->entryCreator->addStationEntry(
                    'Der verlassene Handelsposten in Sektor ' . $ship->getSectorString() . ' ist zerfallen',
                    $ship->getUser()->getId()
                );
                continue;
            }
            $ship->setHuell($ship->getHull() - $lower);

            $this->shipRepository->save($ship);
        }
    }

    private function lowerStationConstructionHull(): void
    {
        foreach ($this->shipRepository->getStationConstructions() as $ship) {
            $lower = random_int(5, 15);
            if ($ship->getHull() <= $lower) {
                $msg = sprintf(_('Dein Konstrukt bei %s war zu lange ungenutzt und ist daher zerfallen'), $ship->getSectorString());
                $this->privateMessageSender->send(
                    UserEnum::USER_NOONE,
                    $ship->getUser()->getId(),
                    $msg,
                    PrivateMessageFolderSpecialEnum::PM_SPECIAL_STATION
                );

                $this->shipRemover->remove($ship);
                continue;
            }
            $ship->setHuell($ship->getHull() - $lower);

            $this->shipRepository->save($ship);
        }
    }

    private function handleNPCShips(): void
    {
        // @todo
        foreach ($this->shipRepository->getNpcShipsForTick() as $ship) {
            //load EPS
            $wrapper = $this->shipWrapperFactory->wrapShip($ship);
            $epsSystem = $wrapper->getEpsSystemData();
            $warpdrive = $wrapper->getWarpDriveSystemData();
            $warpcore = $wrapper->getWarpCoreSystemData();

            if ($epsSystem !== null) {
                if ($warpdrive != null) {
                    $eps = (int) ceil($ship->getReactorOutput() * (($warpcore->getWarpCoreSplit() / 100)) - $wrapper->getEpsUsage());
                } else {
                    $eps = (int) ceil($ship->getReactorOutput() - $wrapper->getEpsUsage());
                }
                if ($eps + $epsSystem->getEps() > $epsSystem->getMaxEps()) {
                    $eps = $epsSystem->getMaxEps() - $epsSystem->getEps();
                }
                $epsSystem->setEps($epsSystem->getEps() + $eps)->update();
            }
            if ($warpdrive !== null) {
                $availableWarpDrive = $warpdrive->getWarpDrive() + $wrapper->getEffectiveWarpDriveProduction();
            } else {
                return;
            }
            if ($warpdrive !== null) {
                if ($availableWarpDrive > $warpdrive->getMaxWarpDrive()) {
                    $availableWarpDrive = $warpdrive->getMaxWarpDrive();
                }
                $warpdrive->setWarpDrive($availableWarpDrive)->update();
            }
        }
    }

    protected function getBenchmark(): Ubench
    {
        return $this->benchmark;
    }

    protected function getLoggerUtil(): LoggerUtilInterface
    {
        return $this->loggerUtil;
    }
}

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Stu\Module\Tick\Ship;
6
7			use Stu\Component\Anomaly\AnomalyHandlingInterface;
8			use Stu\Module\Colony\Lib\ColonyLibFactoryInterface;
9			use Stu\Module\History\Lib\EntryCreatorInterface;
10			use Stu\Module\Logging\LoggerEnum;
11			use Stu\Module\Logging\LoggerUtilFactoryInterface;
12			use Stu\Module\Logging\LoggerUtilInterface;
13			use Stu\Module\Message\Lib\PrivateMessageFolderSpecialEnum;
14			use Stu\Module\Message\Lib\PrivateMessageSenderInterface;
15			use Stu\Module\PlayerSetting\Lib\UserEnum;
16			use Stu\Module\Ship\Lib\ShipRemoverInterface;
17			use Stu\Module\Ship\Lib\ShipWrapperFactoryInterface;
18			use Stu\Module\Tick\AbstractTickManager;
19			use Stu\Module\Tick\Ship\Crew\CrewLimitationsInterface;
20			use Stu\Module\Tick\Ship\Repair\RepairActionsInterface;
21			use Stu\Orm\Entity\ColonyInterface;
22			use Stu\Orm\Entity\ShipInterface;
23			use Stu\Orm\Repository\ShipCrewRepositoryInterface;
24			use Stu\Orm\Repository\ShipRepositoryInterface;
25			use Stu\Orm\Repository\TradePostRepositoryInterface;
26			use Ubench;
27
28			final class ShipTickManager extends AbstractTickManager implements ShipTickManagerInterface
29			{
30			private CrewLimitationsInterface $crewLimitations;
31
32			private PrivateMessageSenderInterface $privateMessageSender;
33
34			private ShipRemoverInterface $shipRemover;
35
36			private ShipTickInterface $shipTick;
37
38			private ShipRepositoryInterface $shipRepository;
39
40			private ShipCrewRepositoryInterface $shipCrewRepository;
41
42			private TradePostRepositoryInterface $tradePostRepository;
43
44			private ShipWrapperFactoryInterface $shipWrapperFactory;
45
46			private EntryCreatorInterface $entryCreator;
47
48			private ColonyLibFactoryInterface $colonyLibFactory;
49
50			private RepairActionsInterface $repairActions;
51
52			private AnomalyHandlingInterface $anomalyHandling;
53
54			private LoggerUtilInterface $loggerUtil;
55
56			private Ubench $benchmark;
57
58			public function __construct(
59			CrewLimitationsInterface $crewLimitations,
60			PrivateMessageSenderInterface $privateMessageSender,
61			ShipRemoverInterface $shipRemover,
62			ShipTickInterface $shipTick,
63			ShipRepositoryInterface $shipRepository,
64			ShipCrewRepositoryInterface $shipCrewRepository,
65			TradePostRepositoryInterface $tradePostRepository,
66			ShipWrapperFactoryInterface $shipWrapperFactory,
67			EntryCreatorInterface $entryCreator,
68			ColonyLibFactoryInterface $colonyLibFactory,
69			RepairActionsInterface $repairActions,
70			AnomalyHandlingInterface $anomalyHandling,
71			LoggerUtilFactoryInterface $loggerUtilFactory,
72			Ubench $benchmark
73			) {
74			$this->crewLimitations = $crewLimitations;
75			$this->privateMessageSender = $privateMessageSender;
76			$this->shipRemover = $shipRemover;
77			$this->shipTick = $shipTick;
78			$this->shipRepository = $shipRepository;
79			$this->shipCrewRepository = $shipCrewRepository;
80			$this->tradePostRepository = $tradePostRepository;
81			$this->shipWrapperFactory = $shipWrapperFactory;
82			$this->entryCreator = $entryCreator;
83			$this->colonyLibFactory = $colonyLibFactory;
84			$this->repairActions = $repairActions;
85			$this->anomalyHandling = $anomalyHandling;
86			$this->loggerUtil = $loggerUtilFactory->getLoggerUtil();
87			$this->benchmark = $benchmark;
88			}
89
90			public function work(): void
91			{
92			$this->anomalyHandling->processExistingAnomalies();
93			$this->crewLimitations->work();
94
95			$startTime = microtime(true);
96			$this->handleEscapePods();
97			if ($this->loggerUtil->doLog()) {
98			$endTime = microtime(true);
99			$this->loggerUtil->log(sprintf("\t\thandleEscapePods, seconds: %F", $endTime - $startTime));
100			}
101			$this->repairActions->work();
102
103			$startTime = microtime(true);
104			$entityCount = 0;
105			foreach ($this->shipRepository->getPlayerShipsForTick() as $ship) {
106			//echo "Processing Ship ".$ship->getId()." at ".microtime()."\n";
107
108			$this->shipTick->work($this->shipWrapperFactory->wrapShip($ship));
109			$entityCount++;
110			}
111			if ($this->loggerUtil->doLog()) {
112			$endTime = microtime(true);
113			$this->loggerUtil->log(sprintf("\t\tshipTick, seconds: %F", $endTime - $startTime));
114			}
115
116			$startTime = microtime(true);
117			$this->handleNPCShips();
118			if ($this->loggerUtil->doLog()) {
119			$endTime = microtime(true);
120			$this->loggerUtil->log(sprintf("\t\thandleNPCShips, seconds: %F", $endTime - $startTime));
121			}
122
123			$startTime = microtime(true);
124			$this->lowerTrumfieldHull();
125			$this->lowerOrphanizedTradepostHull();
126			$this->lowerStationConstructionHull();
127			if ($this->loggerUtil->doLog()) {
128			$endTime = microtime(true);
129			$this->loggerUtil->log(sprintf("\t\tloweringTrumfieldConstruction, seconds: %F", $endTime - $startTime));
130			}
131
132			$this->loggerUtil->init('SHIPTICK', LoggerEnum::LEVEL_WARNING);
133			$this->logBenchmarkResult($entityCount);
134
135			$this->anomalyHandling->createNewAnomalies();
136			}
137
138			private function handleEscapePods(): void
139			{
140			$escapedToColonies = [];
141
142			foreach ($this->shipRepository->getEscapePods() as $escapePod) {
143			if ($escapePod->getCrewCount() === 0) {
144			$this->shipRemover->remove($escapePod);
145			}
146
147			if ($escapePod->getStarsystemMap() !== null) {
148			$colony = $escapePod->getStarsystemMap()->getColony();
149
150			if ($colony !== null) {
151			$count = $this->transferOwnCrewToColony($escapePod, $colony);
152
153			if ($count > 0) {
154			if (array_key_exists($colony->getId(), $escapedToColonies)) {
155			$oldCount = $escapedToColonies[$colony->getId()][1];
156
157			$escapedToColonies[$colony->getId()][1] = $oldCount + $count;
158			} else {
159			$escapedToColonies[$colony->getId()] = [$colony, $count];
160			}
161			}
162			}
163			}
164			}
165
166			foreach ($escapedToColonies as [$colony, $count]) {
167			$msg = sprintf(_('%d deiner Crewman sind aus Fluchtkapseln auf deiner Kolonie %s gelandet'), $count, $colony->getName());
168			$this->privateMessageSender->send(
169			UserEnum::USER_NOONE,
170			$colony->getUser()->getId(),
171			$msg,
172			PrivateMessageFolderSpecialEnum::PM_SPECIAL_COLONY
173			);
174			}
175			}
176
177			private function transferOwnCrewToColony(ShipInterface $escapePod, ColonyInterface $colony): int
178			{
179			$count = 0;
180
181			foreach ($escapePod->getCrewlist() as $crewAssignment) {
182			if ($crewAssignment->getUser() !== $colony->getUser()) {
183			continue;
184			}
185
186			$freeAssignmentCount = $this->colonyLibFactory->createColonyPopulationCalculator(
187			$colony
188			)->getFreeAssignmentCount();
189
190			if ($freeAssignmentCount === 0) {
191			break;
192			}
193
194			$count++;
195			$crewAssignment->setShip(null);
196			$crewAssignment->setSlot(null);
197			$crewAssignment->setColony($colony);
198			$escapePod->getCrewlist()->removeElement($crewAssignment);
199			$colony->getCrewAssignments()->add($crewAssignment);
200			$this->shipCrewRepository->save($crewAssignment);
201			}
202
203			return $count;
204			}
205
206			private function lowerTrumfieldHull(): void
207			{
208			foreach ($this->shipRepository->getDebrisFields() as $ship) {
209			$lower = random_int(5, 15);
210			if ($ship->getHull() <= $lower) {
211			$this->shipRemover->remove($ship);
212			continue;
213			}
214			$ship->setHuell($ship->getHull() - $lower);
215
216			$this->shipRepository->save($ship);
217			}
218			}
219
220			private function lowerOrphanizedTradepostHull(): void
221			{
222			foreach ($this->tradePostRepository->getByUser(UserEnum::USER_NOONE) as $tradepost) {
223			$ship = $tradepost->getShip();
224
225			$lower = (int)ceil($ship->getMaxHull() / 100);
226
227			if ($ship->getHull() <= $lower) {
228			$this->shipRemover->destroy($this->shipWrapperFactory->wrapShip($ship));
229
230			$this->entryCreator->addStationEntry(
231			'Der verlassene Handelsposten in Sektor ' . $ship->getSectorString() . ' ist zerfallen',
232			$ship->getUser()->getId()
233			);
234			continue;
235			}
236			$ship->setHuell($ship->getHull() - $lower);
237
238			$this->shipRepository->save($ship);
239			}
240			}
241
242			private function lowerStationConstructionHull(): void
243			{
244			foreach ($this->shipRepository->getStationConstructions() as $ship) {
245			$lower = random_int(5, 15);
246			if ($ship->getHull() <= $lower) {
247			$msg = sprintf(_('Dein Konstrukt bei %s war zu lange ungenutzt und ist daher zerfallen'), $ship->getSectorString());
248			$this->privateMessageSender->send(
249			UserEnum::USER_NOONE,
250			$ship->getUser()->getId(),
251			$msg,
252			PrivateMessageFolderSpecialEnum::PM_SPECIAL_STATION
253			);
254
255			$this->shipRemover->remove($ship);
256			continue;
257			}
258			$ship->setHuell($ship->getHull() - $lower);
259
260			$this->shipRepository->save($ship);
261			}
262			}
263
264			private function handleNPCShips(): void
265			{
266			// @todo
267			foreach ($this->shipRepository->getNpcShipsForTick() as $ship) {
268			//load EPS
269			$wrapper = $this->shipWrapperFactory->wrapShip($ship);
270			$epsSystem = $wrapper->getEpsSystemData();
271			$warpdrive = $wrapper->getWarpDriveSystemData();
272			$warpcore = $wrapper->getWarpCoreSystemData();
273
274			if ($epsSystem !== null) {
275			if ($warpdrive != null) {
276			$eps = (int) ceil($ship->getReactorOutput() * (($warpcore->getWarpCoreSplit() / 100)) - $wrapper->getEpsUsage());
277			} else {
278			$eps = (int) ceil($ship->getReactorOutput() - $wrapper->getEpsUsage());
279			}
280			if ($eps + $epsSystem->getEps() > $epsSystem->getMaxEps()) {
281			$eps = $epsSystem->getMaxEps() - $epsSystem->getEps();
282			}
283			$epsSystem->setEps($epsSystem->getEps() + $eps)->update();
284			}
285			if ($warpdrive !== null) {
286			$availableWarpDrive = $warpdrive->getWarpDrive() + $wrapper->getEffectiveWarpDriveProduction();
287			} else {
288			return;
289			}
290			if ($warpdrive !== null) {
291			if ($availableWarpDrive > $warpdrive->getMaxWarpDrive()) {
292			$availableWarpDrive = $warpdrive->getMaxWarpDrive();
293			}
294			$warpdrive->setWarpDrive($availableWarpDrive)->update();
295			}
296			}
297			}
298
299			protected function getBenchmark(): Ubench
300			{
301			return $this->benchmark;
302			}
303
304			protected function getLoggerUtil(): LoggerUtilInterface
305			{
306			return $this->loggerUtil;
307			}
308			}

st-universe / core

Push — dev ( ac26ef...6b8aca )

ShipTickManager::getLoggerUtil() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like