AttackBuilding::addMessageMerge() - Code Metrics - Inspection of "refactor move" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 288b46...98b0e3 )

by Nico

created 2023-10-02 07:15 UTC

AttackBuilding::addMessageMerge() A

↳ Parent: AttackBuilding

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Stu\Module\Ship\Action\AttackBuilding;

use request;
use Stu\Component\Building\BuildingEnum;
use Stu\Component\Colony\ColonyFunctionManager;
use Stu\Component\Colony\ColonyFunctionManagerInterface;
use Stu\Lib\InformationWrapper;
use Stu\Module\Colony\Lib\PlanetFieldTypeRetrieverInterface;
use Stu\Module\Control\ActionControllerInterface;
use Stu\Module\Control\GameControllerInterface;
use Stu\Module\Message\Lib\PrivateMessageFolderSpecialEnum;
use Stu\Module\Message\Lib\PrivateMessageSenderInterface;
use Stu\Module\Ship\Lib\Battle\AlertRedHelperInterface;
use Stu\Module\Ship\Lib\Battle\FightLibInterface;
use Stu\Module\Ship\Lib\Message\MessageInterface;
use Stu\Module\Ship\Lib\Battle\Provider\AttackerProviderFactoryInterface;
use Stu\Module\Ship\Lib\Battle\Weapon\EnergyWeaponPhaseInterface;
use Stu\Module\Ship\Lib\Battle\Weapon\ProjectileWeaponPhaseInterface;
use Stu\Module\Ship\Lib\InteractionCheckerInterface;
use Stu\Module\Ship\Lib\ShipLoaderInterface;
use Stu\Module\Ship\View\ShowShip\ShowShip;
use Stu\Orm\Repository\ColonyRepositoryInterface;
use Stu\Orm\Repository\PlanetFieldRepositoryInterface;

final class AttackBuilding implements ActionControllerInterface
{
    public const ACTION_IDENTIFIER = 'B_ATTACK_BUILDING';

    private ShipLoaderInterface $shipLoader;

    private PlanetFieldRepositoryInterface $planetFieldRepository;

    private ColonyRepositoryInterface $colonyRepository;

    private InteractionCheckerInterface $interactionChecker;

    private FightLibInterface $fightLib;

    private EnergyWeaponPhaseInterface $energyWeaponPhase;

    private ProjectileWeaponPhaseInterface $projectileWeaponPhase;

    private PrivateMessageSenderInterface $privateMessageSender;

    private AlertRedHelperInterface $alertRedHelper;

    private InformationWrapper $informations;

    private PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever;

    private ColonyFunctionManagerInterface $colonyFunctionManager;

    private AttackerProviderFactoryInterface $attackerProviderFactory;

    public function __construct(
        ShipLoaderInterface $shipLoader,
        PlanetFieldRepositoryInterface $planetFieldRepository,
        ColonyRepositoryInterface $colonyRepository,
        InteractionCheckerInterface $interactionChecker,
        FightLibInterface $fightLib,
        EnergyWeaponPhaseInterface $energyWeaponPhase,
        ProjectileWeaponPhaseInterface $projectileWeaponPhase,
        PrivateMessageSenderInterface $privateMessageSender,
        AlertRedHelperInterface $alertRedHelper,
        PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever,
        ColonyFunctionManagerInterface $colonyFunctionManager,
        AttackerProviderFactoryInterface $attackerProviderFactory
    ) {
        $this->shipLoader = $shipLoader;
        $this->planetFieldRepository = $planetFieldRepository;
        $this->colonyRepository = $colonyRepository;
        $this->interactionChecker = $interactionChecker;
        $this->fightLib = $fightLib;
        $this->energyWeaponPhase = $energyWeaponPhase;
        $this->projectileWeaponPhase = $projectileWeaponPhase;
        $this->privateMessageSender = $privateMessageSender;
        $this->alertRedHelper = $alertRedHelper;
        $this->planetFieldTypeRetriever = $planetFieldTypeRetriever;
        $this->colonyFunctionManager = $colonyFunctionManager;
        $this->attackerProviderFactory = $attackerProviderFactory;

        $this->informations = new InformationWrapper();
    }

    public function handle(GameControllerInterface $game): void
    {
        $user = $game->getUser();
        $userId = $user->getId();

        $wrapper = $this->shipLoader->getWrapperByIdAndUser(
            request::indInt('id'),
            $userId
        );

        $colonyId = request::getIntFatal('colid');
        $fieldId = request::getIntFatal('field');


        $field = $this->planetFieldRepository->find($fieldId);
        $colony = $this->colonyRepository->find($colonyId);
        if ($field === null || $colony === null) {
            $game->addInformation(_('Feld oder Kolonie nicht vorhanden'));
            return;
        }

        if ($field->getFieldId() >= 80) {
            $game->addInformation(_('Der Untergrund kann nicht attackiert werden'));
            return;
        }

        $ship = $wrapper->get();

        if (!$ship->hasEnoughCrew($game)) {
            return;
        }

        if ($colony->getUser()->isVacationRequestOldEnough()) {
            $game->addInformation(_('Aktion nicht möglich, der Spieler befindet sich im Urlaubsmodus!'));
            return;
        }

        $epsSystem = $wrapper->getEpsSystemData();

        if ($epsSystem === null || $epsSystem->getEps() == 0) {
            $game->addInformation(_('Keine Energie vorhanden'));
            return;
        }
        if ($ship->isDisabled()) {
            $game->addInformation(_('Das Schiff ist kampfunfähig'));
            return;
        }

        if ($colony->getId() !== $field->getColonyId()) {
            return;
        }
        if (!$this->interactionChecker->checkColonyPosition($colony, $ship)) {
            return;
        }

        $isFleetAttack = false;
        $fleetWrapper = $wrapper->getFleetWrapper();
        if ($ship->isFleetLeader() && $fleetWrapper !== null) {
            $attackers = $fleetWrapper->getShipWrappers();
            $isFleetAttack = true;
        } else {
            $attackers = [$ship->getId() => $wrapper];
        }

        foreach ($attackers as $attackship) {
            $this->informations->addInformationWrapper($this->fightLib->ready($attackship));
        }

        // DEFENDING FLEETS
        foreach ($colony->getDefenders() as $fleet) {
            $this->alertRedHelper->performAttackCycle($fleet->getLeadShip(), $ship, $this->informations, true);
        }

        // ORBITAL DEFENSE
        $count = $this->colonyFunctionManager->getBuildingWithFunctionCount(
            $colony,
            BuildingEnum::BUILDING_FUNCTION_ENERGY_PHALANX,
            [ColonyFunctionManager::STATE_ENABLED]
        );
        $defendingPhalanx =  $this->attackerProviderFactory->getEnergyPhalanxAttacker($colony);

        for ($i = 0; $i < $count; $i++) {
            $attackerPool = $this->fightLib->filterInactiveShips($attackers);

            if ($attackerPool === []) {
                break;
            }
            $this->addMessageMerge($this->energyWeaponPhase->fire($defendingPhalanx, $attackerPool));
        }

        $count = $this->colonyFunctionManager->getBuildingWithFunctionCount(
            $colony,
            BuildingEnum::BUILDING_FUNCTION_PARTICLE_PHALANX,
            [ColonyFunctionManager::STATE_ENABLED]
        );
        $defendingPhalanx = $this->attackerProviderFactory->getProjectilePhalanxAttacker($colony);

        for ($i = 0; $i < $count; $i++) {
            $attackerPool = $this->fightLib->filterInactiveShips($attackers);

            if ($attackerPool === []) {
                break;
            }
            $this->addMessageMerge($this->projectileWeaponPhase->fire($defendingPhalanx, $attackerPool));
        }

        // OFFENSE OF ATTACKING SHIPS
        $isOrbitField = $this->planetFieldTypeRetriever->isOrbitField($field);
        $attackerPool = $this->fightLib->filterInactiveShips($attackers);
        $count = $this->colonyFunctionManager->getBuildingWithFunctionCount(
            $colony,
            BuildingEnum::BUILDING_FUNCTION_ANTI_PARTICLE,
            [ColonyFunctionManager::STATE_ENABLED]
        ) * 6;

        foreach ($attackerPool as $attackerWrapper) {
            $shipAttacker = $this->attackerProviderFactory->getShipAttacker($attackerWrapper);

            if ($isOrbitField) {
                $this->informations->addInformationWrapper($this->energyWeaponPhase->fireAtBuilding($shipAttacker, $field, $isOrbitField));

                if ($field->getIntegrity() === 0) {
                    break;
                }
            }
            $this->informations->addInformationWrapper($this->projectileWeaponPhase->fireAtBuilding($shipAttacker, $field, $isOrbitField, $count));

            if ($field->getIntegrity() === 0) {
                break;
            }
        }

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

        $pm = sprintf(
            _("Kampf in Sektor %s, Kolonie %s\n%s"),
            $ship->getSectorString(),
            $colony->getName(),
            $this->informations->getInformationsAsString()
        );
        $this->privateMessageSender->send(
            $userId,
            $colony->getUserId(),
            $pm,
            PrivateMessageFolderSpecialEnum::PM_SPECIAL_COLONY
        );

        if ($ship->isDestroyed()) {
            $game->addInformationWrapper($this->informations);
            return;
        }
        $game->setView(ShowShip::VIEW_IDENTIFIER);

        if ($isFleetAttack) {
            $game->addInformation(_("Angriff durchgeführt"));
            $game->setTemplateVar('FIGHT_RESULTS', $this->informations->getInformations());
        } else {
            $game->addInformationWrapper($this->informations);
            $game->setTemplateVar('FIGHT_RESULTS', null);
        }
    }

    /**
     * @param MessageInterface[] $messages
     */
    private function addMessageMerge(array $messages): void
    {
        foreach ($messages as $message) {
            $this->informations->addInformationArray($message->getMessage());
        }
    }

    public function performSessionCheck(): bool
    {
        return true;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Stu\Module\Ship\Action\AttackBuilding;
6
7			use request;
8			use Stu\Component\Building\BuildingEnum;
9			use Stu\Component\Colony\ColonyFunctionManager;
10			use Stu\Component\Colony\ColonyFunctionManagerInterface;
11			use Stu\Lib\InformationWrapper;
12			use Stu\Module\Colony\Lib\PlanetFieldTypeRetrieverInterface;
13			use Stu\Module\Control\ActionControllerInterface;
14			use Stu\Module\Control\GameControllerInterface;
15			use Stu\Module\Message\Lib\PrivateMessageFolderSpecialEnum;
16			use Stu\Module\Message\Lib\PrivateMessageSenderInterface;
17			use Stu\Module\Ship\Lib\Battle\AlertRedHelperInterface;
18			use Stu\Module\Ship\Lib\Battle\FightLibInterface;
19			use Stu\Module\Ship\Lib\Message\MessageInterface;
20			use Stu\Module\Ship\Lib\Battle\Provider\AttackerProviderFactoryInterface;
21			use Stu\Module\Ship\Lib\Battle\Weapon\EnergyWeaponPhaseInterface;
22			use Stu\Module\Ship\Lib\Battle\Weapon\ProjectileWeaponPhaseInterface;
23			use Stu\Module\Ship\Lib\InteractionCheckerInterface;
24			use Stu\Module\Ship\Lib\ShipLoaderInterface;
25			use Stu\Module\Ship\View\ShowShip\ShowShip;
26			use Stu\Orm\Repository\ColonyRepositoryInterface;
27			use Stu\Orm\Repository\PlanetFieldRepositoryInterface;
28
29			final class AttackBuilding implements ActionControllerInterface
30			{
31			public const ACTION_IDENTIFIER = 'B_ATTACK_BUILDING';
32
33			private ShipLoaderInterface $shipLoader;
34
35			private PlanetFieldRepositoryInterface $planetFieldRepository;
36
37			private ColonyRepositoryInterface $colonyRepository;
38
39			private InteractionCheckerInterface $interactionChecker;
40
41			private FightLibInterface $fightLib;
42
43			private EnergyWeaponPhaseInterface $energyWeaponPhase;
44
45			private ProjectileWeaponPhaseInterface $projectileWeaponPhase;
46
47			private PrivateMessageSenderInterface $privateMessageSender;
48
49			private AlertRedHelperInterface $alertRedHelper;
50
51			private InformationWrapper $informations;
52
53			private PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever;
54
55			private ColonyFunctionManagerInterface $colonyFunctionManager;
56
57			private AttackerProviderFactoryInterface $attackerProviderFactory;
58
59			public function __construct(
60			ShipLoaderInterface $shipLoader,
61			PlanetFieldRepositoryInterface $planetFieldRepository,
62			ColonyRepositoryInterface $colonyRepository,
63			InteractionCheckerInterface $interactionChecker,
64			FightLibInterface $fightLib,
65			EnergyWeaponPhaseInterface $energyWeaponPhase,
66			ProjectileWeaponPhaseInterface $projectileWeaponPhase,
67			PrivateMessageSenderInterface $privateMessageSender,
68			AlertRedHelperInterface $alertRedHelper,
69			PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever,
70			ColonyFunctionManagerInterface $colonyFunctionManager,
71			AttackerProviderFactoryInterface $attackerProviderFactory
72			) {
73			$this->shipLoader = $shipLoader;
74			$this->planetFieldRepository = $planetFieldRepository;
75			$this->colonyRepository = $colonyRepository;
76			$this->interactionChecker = $interactionChecker;
77			$this->fightLib = $fightLib;
78			$this->energyWeaponPhase = $energyWeaponPhase;
79			$this->projectileWeaponPhase = $projectileWeaponPhase;
80			$this->privateMessageSender = $privateMessageSender;
81			$this->alertRedHelper = $alertRedHelper;
82			$this->planetFieldTypeRetriever = $planetFieldTypeRetriever;
83			$this->colonyFunctionManager = $colonyFunctionManager;
84			$this->attackerProviderFactory = $attackerProviderFactory;
85
86			$this->informations = new InformationWrapper();
87			}
88
89			public function handle(GameControllerInterface $game): void
90			{
91			$user = $game->getUser();
92			$userId = $user->getId();
93
94			$wrapper = $this->shipLoader->getWrapperByIdAndUser(
95			request::indInt('id'),
96			$userId
97			);
98
99			$colonyId = request::getIntFatal('colid');
100			$fieldId = request::getIntFatal('field');
101
102
103			$field = $this->planetFieldRepository->find($fieldId);
104			$colony = $this->colonyRepository->find($colonyId);
105			if ($field === null \|\| $colony === null) {
106			$game->addInformation(_('Feld oder Kolonie nicht vorhanden'));
107			return;
108			}
109
110			if ($field->getFieldId() >= 80) {
111			$game->addInformation(_('Der Untergrund kann nicht attackiert werden'));
112			return;
113			}
114
115			$ship = $wrapper->get();
116
117			if (!$ship->hasEnoughCrew($game)) {
118			return;
119			}
120
121			if ($colony->getUser()->isVacationRequestOldEnough()) {
122			$game->addInformation(_('Aktion nicht möglich, der Spieler befindet sich im Urlaubsmodus!'));
123			return;
124			}
125
126			$epsSystem = $wrapper->getEpsSystemData();
127
128			if ($epsSystem === null \|\| $epsSystem->getEps() == 0) {
129			$game->addInformation(_('Keine Energie vorhanden'));
130			return;
131			}
132			if ($ship->isDisabled()) {
133			$game->addInformation(_('Das Schiff ist kampfunfähig'));
134			return;
135			}
136
137			if ($colony->getId() !== $field->getColonyId()) {
138			return;
139			}
140			if (!$this->interactionChecker->checkColonyPosition($colony, $ship)) {
141			return;
142			}
143
144			$isFleetAttack = false;
145			$fleetWrapper = $wrapper->getFleetWrapper();
146			if ($ship->isFleetLeader() && $fleetWrapper !== null) {
147			$attackers = $fleetWrapper->getShipWrappers();
148			$isFleetAttack = true;
149			} else {
150			$attackers = [$ship->getId() => $wrapper];
151			}
152
153			foreach ($attackers as $attackship) {
154			$this->informations->addInformationWrapper($this->fightLib->ready($attackship));
155			}
156
157			// DEFENDING FLEETS
158			foreach ($colony->getDefenders() as $fleet) {
159			$this->alertRedHelper->performAttackCycle($fleet->getLeadShip(), $ship, $this->informations, true);
160			}
161
162			// ORBITAL DEFENSE
163			$count = $this->colonyFunctionManager->getBuildingWithFunctionCount(
164			$colony,
165			BuildingEnum::BUILDING_FUNCTION_ENERGY_PHALANX,
166			[ColonyFunctionManager::STATE_ENABLED]
167			);
168			$defendingPhalanx = $this->attackerProviderFactory->getEnergyPhalanxAttacker($colony);
169
170			for ($i = 0; $i < $count; $i++) {
171			$attackerPool = $this->fightLib->filterInactiveShips($attackers);
172
173			if ($attackerPool === []) {
174			break;
175			}
176			$this->addMessageMerge($this->energyWeaponPhase->fire($defendingPhalanx, $attackerPool));
177			}
178
179			$count = $this->colonyFunctionManager->getBuildingWithFunctionCount(
180			$colony,
181			BuildingEnum::BUILDING_FUNCTION_PARTICLE_PHALANX,
182			[ColonyFunctionManager::STATE_ENABLED]
183			);
184			$defendingPhalanx = $this->attackerProviderFactory->getProjectilePhalanxAttacker($colony);
185
186			for ($i = 0; $i < $count; $i++) {
187			$attackerPool = $this->fightLib->filterInactiveShips($attackers);
188
189			if ($attackerPool === []) {
190			break;
191			}
192			$this->addMessageMerge($this->projectileWeaponPhase->fire($defendingPhalanx, $attackerPool));
193			}
194
195			// OFFENSE OF ATTACKING SHIPS
196			$isOrbitField = $this->planetFieldTypeRetriever->isOrbitField($field);
197			$attackerPool = $this->fightLib->filterInactiveShips($attackers);
198			$count = $this->colonyFunctionManager->getBuildingWithFunctionCount(
199			$colony,
200			BuildingEnum::BUILDING_FUNCTION_ANTI_PARTICLE,
201			[ColonyFunctionManager::STATE_ENABLED]
202			) * 6;
203
204			foreach ($attackerPool as $attackerWrapper) {
205			$shipAttacker = $this->attackerProviderFactory->getShipAttacker($attackerWrapper);
206
207			if ($isOrbitField) {
208			$this->informations->addInformationWrapper($this->energyWeaponPhase->fireAtBuilding($shipAttacker, $field, $isOrbitField));
209
210			if ($field->getIntegrity() === 0) {
211			break;
212			}
213			}
214			$this->informations->addInformationWrapper($this->projectileWeaponPhase->fireAtBuilding($shipAttacker, $field, $isOrbitField, $count));
215
216			if ($field->getIntegrity() === 0) {
217			break;
218			}
219			}
220
221			$this->colonyRepository->save($colony);
222
223			$pm = sprintf(
224			_("Kampf in Sektor %s, Kolonie %s\n%s"),
225			$ship->getSectorString(),
226			$colony->getName(),
227			$this->informations->getInformationsAsString()
228			);
229			$this->privateMessageSender->send(
230			$userId,
231			$colony->getUserId(),
232			$pm,
233			PrivateMessageFolderSpecialEnum::PM_SPECIAL_COLONY
234			);
235
236			if ($ship->isDestroyed()) {
237			$game->addInformationWrapper($this->informations);
238			return;
239			}
240			$game->setView(ShowShip::VIEW_IDENTIFIER);
241
242			if ($isFleetAttack) {
243			$game->addInformation(_("Angriff durchgeführt"));
244			$game->setTemplateVar('FIGHT_RESULTS', $this->informations->getInformations());
245			} else {
246			$game->addInformationWrapper($this->informations);
247			$game->setTemplateVar('FIGHT_RESULTS', null);
248			}
249			}
250
251			/**
252			* @param MessageInterface[] $messages
253			*/
254			private function addMessageMerge(array $messages): void
255			{
256			foreach ($messages as $message) {
257			$this->informations->addInformationArray($message->getMessage());
258			}
259			}
260
261			public function performSessionCheck(): bool
262			{
263			return true;
264			}
265			}
266

st-universe / core

Push — master ( 288b46...98b0e3 )

AttackBuilding::addMessageMerge() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like