ShipTickManager::clearLock() - Code Metrics - Inspection of "Dev" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1716)

by Nico

created 2023-12-11 16:41 UTC

ShipTickManager::clearLock() 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	1
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\Lock\LockManagerInterface;
use Stu\Module\Tick\Lock\LockTypeEnum;
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 LockManagerInterface $lockManager;

    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,
        LockManagerInterface $lockManager,
        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->lockManager = $lockManager;
        $this->loggerUtil = $loggerUtilFactory->getLoggerUtil();
        $this->benchmark = $benchmark;
    }

    public function work(): void
    {
        $this->setLock(1);

        try {
            $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();
        } finally {
            $this->clearLock(1);
        }
    }

    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->getCrewAssignments() 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->getCrewAssignments()->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) {
            $wrapper = $this->shipWrapperFactory->wrapShip($ship);
            $reactor = $wrapper->getReactorWrapper();
            if ($reactor === null) {
                continue;
            }

            $epsSystem = $wrapper->getEpsSystemData();
            $warpdrive = $wrapper->getWarpDriveSystemData();

            //load EPS
            if ($epsSystem !== null) {
                $epsSystem->setEps($epsSystem->getEps() + $reactor->getEffectiveEpsProduction())->update();
            }

            //load warpdrive
            if ($warpdrive !== null) {
                $warpdrive->setWarpDrive($warpdrive->getWarpDrive() + $reactor->getEffectiveWarpDriveProduction())->update();
            }
        }
    }

    private function setLock(int $batchGroupId): void
    {
        $this->lockManager->setLock($batchGroupId, LockTypeEnum::SHIP_GROUP);
    }

    private function clearLock(int $batchGroupId): void
    {
        $this->lockManager->clearLock($batchGroupId, LockTypeEnum::SHIP_GROUP);
    }

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

st-universe / core

Pull Request — master (#1716)

ShipTickManager::clearLock() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like