ActivatorDeactivatorHelper::setLSSMode() - Code Metrics - Inspection of "fix" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 6288df...4d55dd )

by Nico

created 2023-08-19 21:07 UTC

ActivatorDeactivatorHelper::setLSSMode() A

↳ Parent: ActivatorDeactivatorHelper

Complexity

Conditions	3
Paths	3

Size

Total Lines	19
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
cc	3
eloc	10
nc	3
nop	3
dl	0
loc	19
ccs	0
cts	12
cp	0
crap	12
rs	9.9332
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Stu\Module\Ship\Lib;

use RuntimeException;
use Stu\Component\Ship\ShipAlertStateEnum;
use Stu\Component\Ship\ShipLSSModeEnum;
use Stu\Component\Ship\System\Exception\ActivationConditionsNotMetException;
use Stu\Component\Ship\System\Exception\AlreadyActiveException;
use Stu\Component\Ship\System\Exception\AlreadyOffException;
use Stu\Component\Ship\System\Exception\DeactivationConditionsNotMetException;
use Stu\Component\Ship\System\Exception\InsufficientCrewException;
use Stu\Component\Ship\System\Exception\InsufficientEnergyException;
use Stu\Component\Ship\System\Exception\ShipSystemException;
use Stu\Component\Ship\System\Exception\SystemCooldownException;
use Stu\Component\Ship\System\Exception\SystemDamagedException;
use Stu\Component\Ship\System\Exception\SystemNotActivatableException;
use Stu\Component\Ship\System\Exception\SystemNotDeactivatableException;
use Stu\Component\Ship\System\Exception\SystemNotFoundException;
use Stu\Component\Ship\System\ShipSystemManagerInterface;
use Stu\Component\Ship\System\ShipSystemTypeEnum;
use Stu\Module\Control\GameControllerInterface;
use Stu\Module\Tal\TalHelper;
use Stu\Orm\Repository\ShipRepositoryInterface;

final class ActivatorDeactivatorHelper implements ActivatorDeactivatorHelperInterface
{
    private ShipLoaderInterface $shipLoader;

    private ShipRepositoryInterface $shipRepository;

    private ShipSystemManagerInterface $shipSystemManager;

    public function __construct(
        ShipLoaderInterface $shipLoader,
        ShipRepositoryInterface $shipRepository,
        ShipSystemManagerInterface $shipSystemManager
    ) {
        $this->shipLoader = $shipLoader;
        $this->shipRepository = $shipRepository;
        $this->shipSystemManager = $shipSystemManager;
    }

    public function activate(
        ShipWrapperInterface|int $target,
        int $systemId,
        GameControllerInterface $game,
        bool $allowUplink = false
    ): bool {
        $userId = $game->getUser()->getId();

        $wrapper = $this->getTargetWrapper(
            $target,
            $userId,
            $allowUplink
        );

        if ($this->activateIntern($wrapper, $systemId, $game)) {
            $this->shipRepository->save($wrapper->get());
            return true;
        } else {
            return false;
        }
    }

    private function getTargetWrapper(
        ShipWrapperInterface|int $target,
        int $userId,
        bool $allowUplink
    ): ShipWrapperInterface {
        if ($target instanceof ShipWrapperInterface) {
            return $target;
        }

        return $this->shipLoader->getWrapperByIdAndUser(
            $target,
            $userId,
            $allowUplink
        );
    }

    private function activateIntern(
        ShipWrapperInterface $wrapper,
        int $systemId,
        GameControllerInterface $game
    ): bool {
        $systemName = ShipSystemTypeEnum::getDescription($systemId);
        $ship = $wrapper->get();

        try {
            $this->shipSystemManager->activate($wrapper, $systemId);
            $game->addInformation(sprintf(_('%s: System %s aktiviert'), $ship->getName(), $systemName));
            return true;
        } catch (AlreadyActiveException $e) {
            $game->addInformation(sprintf(_('%s: System %s ist bereits aktiviert'), $ship->getName(), $systemName));
        } catch (SystemNotActivatableException $e) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s besitzt keinen Aktivierungsmodus[/color][/b]'), $ship->getName(), $systemName));
        } catch (InsufficientEnergyException $e) {
            $game->addInformation(sprintf(
                _('%s: [b][color=#ff2626]System %s kann aufgrund Energiemangels (%d benötigt) nicht aktiviert werden[/color][/b]'),
                $ship->getName(),
                $systemName,
                $e->getNeededEnergy()
            ));
        } catch (SystemCooldownException $e) {
            $game->addInformation(sprintf(
                _('%s: [b][color=#ff2626]System %s kann nicht aktiviert werden, Cooldown noch %s[/color][/b]'),
                $ship->getName(),
                $systemName,
                TalHelper::formatSeconds((string) $e->getRemainingSeconds())
            ));
        } catch (SystemDamagedException $e) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s ist beschädigt und kann daher nicht aktiviert werden[/color][/b]'), $ship->getName(), $systemName));
        } catch (ActivationConditionsNotMetException $e) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s konnte nicht aktiviert werden, weil %s[/color][/b]'), $ship->getName(), $systemName, $e->getMessage()));
        } catch (SystemNotFoundException $e) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s nicht vorhanden[/color][/b]'), $ship->getName(), $systemName));
        } catch (InsufficientCrewException $e) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s konnte wegen Mangel an Crew nicht aktiviert werden[/color][/b]'), $ship->getName(), $systemName));
        } catch (ShipSystemException $e) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s konnte nicht aktiviert werden[/color][/b]'), $ship->getName(), $systemName));
        }

        return false;
    }

    public function activateFleet(
        int $shipId,
        int $systemId,
        GameControllerInterface $game
    ): void {
        $userId = $game->getUser()->getId();

        $wrapper = $this->shipLoader->getWrapperByIdAndUser(
            $shipId,
            $userId
        );

        $fleetWrapper = $wrapper->getFleetWrapper();
        if ($fleetWrapper === null) {
            throw new RuntimeException('ship not in fleet');
        }

        $success = false;
        foreach ($fleetWrapper->getShipWrappers() as $wrapper) {
            if ($this->activateIntern($wrapper, $systemId, $game)) {
                $success = true;
                $this->shipRepository->save($wrapper->get());
            }
        }

        // only show info if at least one ship was able to change
        if (!$success) {
            return;
        }

        $systemName = ShipSystemTypeEnum::getDescription($systemId);
        $game->addInformation(sprintf(_('Flottenbefehl ausgeführt: System %s aktiviert'), $systemName));
    }

    public function deactivate(
        int $shipId,
        int $systemId,
        GameControllerInterface $game,
        bool $allowUplink = false
    ): bool {
        $userId = $game->getUser()->getId();

        $wrapper = $this->shipLoader->getWrapperByIdAndUser(
            $shipId,
            $userId,
            $allowUplink
        );

        if ($this->deactivateIntern($wrapper, $systemId, $game)) {
            $this->shipRepository->save($wrapper->get());
            return true;
        } else {
            return false;
        }
    }

    private function deactivateIntern(
        ShipWrapperInterface $wrapper,
        int $systemId,
        GameControllerInterface $game
    ): bool {
        $systemName = ShipSystemTypeEnum::getDescription($systemId);
        $ship = $wrapper->get();

        try {
            $this->shipSystemManager->deactivate($wrapper, $systemId);
            $game->addInformation(sprintf(_('%s: System %s deaktiviert'), $ship->getName(), $systemName));
            return true;
        } catch (AlreadyOffException $e) {
            $game->addInformation(sprintf(_('%s: System %s ist bereits deaktiviert'), $ship->getName(), $systemName));
        } catch (SystemNotDeactivatableException $e) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s besitzt keinen Deaktivierungsmodus[/color][/b]'), $ship->getName(), $systemName));
        } catch (DeactivationConditionsNotMetException $e) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s konnte nicht deaktiviert werden, weil %s[/color][/b]'), $ship->getName(), $systemName, $e->getMessage()));
        } catch (SystemNotFoundException $e) {
            $game->addInformation(sprintf(_('%s: System %s nicht vorhanden'), $ship->getName(), $systemName));
        }

        return false;
    }

    public function deactivateFleet(
        int $shipId,
        int $systemId,
        GameControllerInterface $game
    ): void {
        $userId = $game->getUser()->getId();

        $wrapper = $this->shipLoader->getWrapperByIdAndUser(
            $shipId,
            $userId
        );

        $fleetWrapper = $wrapper->getFleetWrapper();
        if ($fleetWrapper === null) {
            throw new RuntimeException('ship not in fleet');
        }

        $success = false;
        foreach ($fleetWrapper->getShipWrappers() as $wrapper) {
            if ($this->deactivateIntern($wrapper, $systemId, $game)) {
                $success = true;
                $this->shipRepository->save($wrapper->get());
            }
        }

        // only show info if at least one ship was able to change
        if (!$success) {
            return;
        }

        $systemName = ShipSystemTypeEnum::getDescription($systemId);
        $game->addInformation(sprintf(_('Flottenbefehl ausgeführt: System %s deaktiviert'), $systemName));
    }

    public function setLSSMode(
        int $shipId,
        int $lssMode,
        GameControllerInterface $game
    ): void {
        $userId = $game->getUser()->getId();

        $ship = $this->shipLoader->getByIdAndUser(
            $shipId,
            $userId
        );

        $ship->setLSSMode($lssMode);
        $this->shipRepository->save($ship);

        if ($lssMode === ShipLSSModeEnum::LSS_NORMAL) {
            $game->addInformation("Territoriale Grenzanzeige deaktiviert");
        } elseif ($lssMode === ShipLSSModeEnum::LSS_BORDER) {
            $game->addInformation("Territoriale Grenzanzeige aktiviert");
        }
    }

    public function setAlertState(
        int $shipId,
        int $alertState,
        GameControllerInterface $game
    ): void {
        $userId = $game->getUser()->getId();

        $wrapper = $this->shipLoader->getWrapperByIdAndUser(
            $shipId,
            $userId
        );

        if (!$this->setAlertStateShip($wrapper, $alertState, $game)) {
            return;
        }

        if ($alertState === ShipAlertStateEnum::ALERT_RED) {
            $game->addInformation("Die Alarmstufe wurde auf [b][color=red]Rot[/color][/b] geändert");
        } elseif ($alertState === ShipAlertStateEnum::ALERT_YELLOW) {
            $game->addInformation("Die Alarmstufe wurde auf [b][color=yellow]Gelb[/color][/b] geändert");
        } elseif ($alertState === ShipAlertStateEnum::ALERT_GREEN) {
            $game->addInformation("Die Alarmstufe wurde auf [b][color=green]Grün[/color][/b] geändert");
        }
    }

    public function setAlertStateFleet(
        int $shipId,
        int $alertState,
        GameControllerInterface $game
    ): void {
        $userId = $game->getUser()->getId();

        $wrapper = $this->shipLoader->getWrapperByIdAndUser(
            $shipId,
            $userId
        );

        $fleetWrapper = $wrapper->getFleetWrapper();
        if ($fleetWrapper === null) {
            throw new RuntimeException('ship not in fleet');
        }

        $success = false;
        foreach ($fleetWrapper->getShipWrappers() as $wrapper) {
            $success = $this->setAlertStateShip($wrapper, $alertState, $game) || $success;
        }

        // only show info if at least one ship was able to change
        if (!$success) {
            return;
        }

        if ($alertState === ShipAlertStateEnum::ALERT_RED) {
            $game->addInformation(_('Flottenbefehl ausgeführt: Alarmstufe [b][color=red]Rot[/color][/b]'));
        } elseif ($alertState === ShipAlertStateEnum::ALERT_YELLOW) {
            $game->addInformation(_('Flottenbefehl ausgeführt: Alarmstufe [b][color=yellow]Gelb[/color][/b]'));
        } elseif ($alertState === ShipAlertStateEnum::ALERT_GREEN) {
            $game->addInformation(_('Flottenbefehl ausgeführt: Alarmstufe [b][color=green]Grün[/color][/b]'));
        }
    }

    private function setAlertStateShip(ShipWrapperInterface $wrapper, int $alertState, GameControllerInterface $game): bool
    {
        $ship = $wrapper->get();

        // station constructions can't change alert state
        if ($ship->isConstruction()) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]Konstrukte können die Alarmstufe nicht ändern[/color][/b]'), $ship->getName()));
            return false;
        }

        // can only change when there is enough crew
        if (!$ship->hasEnoughCrew()) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]Mangel an Crew verhindert den Wechsel der Alarmstufe[/color][/b]'), $ship->getName()));
            return false;
        }

        if ($alertState === ShipAlertStateEnum::ALERT_RED && $ship->getCloakState()) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]Tarnung verhindert den Wechsel zu Alarm-Rot[/color][/b]'), $ship->getName()));
            return false;
        }

        try {
            $alertMsg = $wrapper->setAlertState($alertState);
            $this->shipRepository->save($ship);

            if ($alertMsg !== null) {
                $game->addInformation(sprintf(_('%s: [b][color=FAFA03]%s[/color][/b]'), $ship->getName(), $alertMsg));
            }
        } catch (InsufficientEnergyException $e) {
            $game->addInformation(sprintf(_('%s: [b][color=#ff2626]Nicht genügend Energie um die Alarmstufe zu wechseln (%d benötigt)[/color][/b]'), $ship->getName(), $e->getNeededEnergy()));
            return false;
        }

        switch ($alertState) {
            case ShipAlertStateEnum::ALERT_RED:
                $this->setAlertRed($wrapper, $game);
                break;
            case ShipAlertStateEnum::ALERT_YELLOW:
                $this->setAlertYellow($wrapper, $game);
                break;
            case ShipAlertStateEnum::ALERT_GREEN:
                $this->setAlertGreen($wrapper, $game);
                break;
        }

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

        return true;
    }

    private function setAlertRed(ShipWrapperInterface $wrapper, GameControllerInterface $game): void
    {
        $alertSystems = [
            ShipSystemTypeEnum::SYSTEM_SHIELDS,
            ShipSystemTypeEnum::SYSTEM_NBS,
            ShipSystemTypeEnum::SYSTEM_PHASER,
            ShipSystemTypeEnum::SYSTEM_TORPEDO
        ];

        foreach ($alertSystems as $systemId) {
            $this->activateIntern($wrapper, $systemId, $game);
        }
    }

    private function setAlertYellow(ShipWrapperInterface $wrapper, GameControllerInterface $game): void
    {
        $alertSystems = [
            ShipSystemTypeEnum::SYSTEM_NBS
        ];

        foreach ($alertSystems as $systemId) {
            $this->activateIntern($wrapper, $systemId, $game);
        }
    }

    private function setAlertGreen(ShipWrapperInterface $wrapper, GameControllerInterface $game): void
    {
        $deactivateSystems = [
            ShipSystemTypeEnum::SYSTEM_PHASER,
            ShipSystemTypeEnum::SYSTEM_TORPEDO,
            ShipSystemTypeEnum::SYSTEM_SHIELDS
        ];

        foreach ($deactivateSystems as $systemId) {
            if ($wrapper->get()->hasShipSystem($systemId)) {
                $this->deactivateIntern($wrapper, $systemId, $game);
            }
        }
    }

    public function setWarpSplitFleet(
        int $shipId,
        GameControllerInterface $game
    ): void {
        $userId = $game->getUser()->getId();

        $wrapper = $this->shipLoader->getWrapperByIdAndUser(
            $shipId,
            $userId
        );
        $warpsplit = $wrapper->getWarpCoreSystemData()->getWarpCoreSplit();

        $fleetWrapper = $wrapper->getFleetWrapper();
        if ($fleetWrapper === null) {
            throw new RuntimeException('ship not in fleet');
        }

        $success = false;
        foreach ($fleetWrapper->getShipWrappers() as $wrapper) {
            if ($wrapper->getWarpDriveSystemData() !== null) {
                $success = true;
                $wrapper->getWarpCoreSystemData()->setWarpCoreSplit($warpsplit)->update();
            }
        }

        // only show info if at least one ship was able to change
        if (!$success) {
            return;
        }


        $game->addInformation(sprintf(_('Flottenbefehl ausgeführt: Warpkernsplit von %d Prozent auf Flotte angewendet'), $warpsplit));
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Stu\Module\Ship\Lib;
6
7			use RuntimeException;
8			use Stu\Component\Ship\ShipAlertStateEnum;
9			use Stu\Component\Ship\ShipLSSModeEnum;
10			use Stu\Component\Ship\System\Exception\ActivationConditionsNotMetException;
11			use Stu\Component\Ship\System\Exception\AlreadyActiveException;
12			use Stu\Component\Ship\System\Exception\AlreadyOffException;
13			use Stu\Component\Ship\System\Exception\DeactivationConditionsNotMetException;
14			use Stu\Component\Ship\System\Exception\InsufficientCrewException;
15			use Stu\Component\Ship\System\Exception\InsufficientEnergyException;
16			use Stu\Component\Ship\System\Exception\ShipSystemException;
17			use Stu\Component\Ship\System\Exception\SystemCooldownException;
18			use Stu\Component\Ship\System\Exception\SystemDamagedException;
19			use Stu\Component\Ship\System\Exception\SystemNotActivatableException;
20			use Stu\Component\Ship\System\Exception\SystemNotDeactivatableException;
21			use Stu\Component\Ship\System\Exception\SystemNotFoundException;
22			use Stu\Component\Ship\System\ShipSystemManagerInterface;
23			use Stu\Component\Ship\System\ShipSystemTypeEnum;
24			use Stu\Module\Control\GameControllerInterface;
25			use Stu\Module\Tal\TalHelper;
26			use Stu\Orm\Repository\ShipRepositoryInterface;
27
28			final class ActivatorDeactivatorHelper implements ActivatorDeactivatorHelperInterface
29			{
30			private ShipLoaderInterface $shipLoader;
31
32			private ShipRepositoryInterface $shipRepository;
33
34			private ShipSystemManagerInterface $shipSystemManager;
35
36			public function __construct(
37			ShipLoaderInterface $shipLoader,
38			ShipRepositoryInterface $shipRepository,
39			ShipSystemManagerInterface $shipSystemManager
40			) {
41			$this->shipLoader = $shipLoader;
42			$this->shipRepository = $shipRepository;
43			$this->shipSystemManager = $shipSystemManager;
44			}
45
46			public function activate(
47			ShipWrapperInterface\|int $target,
48			int $systemId,
49			GameControllerInterface $game,
50			bool $allowUplink = false
51			): bool {
52			$userId = $game->getUser()->getId();
53
54			$wrapper = $this->getTargetWrapper(
55			$target,
56			$userId,
57			$allowUplink
58			);
59
60			if ($this->activateIntern($wrapper, $systemId, $game)) {
61			$this->shipRepository->save($wrapper->get());
62			return true;
63			} else {
64			return false;
65			}
66			}
67
68			private function getTargetWrapper(
69			ShipWrapperInterface\|int $target,
70			int $userId,
71			bool $allowUplink
72			): ShipWrapperInterface {
73			if ($target instanceof ShipWrapperInterface) {
74			return $target;
75			}
76
77			return $this->shipLoader->getWrapperByIdAndUser(
78			$target,
79			$userId,
80			$allowUplink
81			);
82			}
83
84			private function activateIntern(
85			ShipWrapperInterface $wrapper,
86			int $systemId,
87			GameControllerInterface $game
88			): bool {
89			$systemName = ShipSystemTypeEnum::getDescription($systemId);
90			$ship = $wrapper->get();
91
92			try {
93			$this->shipSystemManager->activate($wrapper, $systemId);
94			$game->addInformation(sprintf(_('%s: System %s aktiviert'), $ship->getName(), $systemName));
95			return true;
96			} catch (AlreadyActiveException $e) {
97			$game->addInformation(sprintf(_('%s: System %s ist bereits aktiviert'), $ship->getName(), $systemName));
98			} catch (SystemNotActivatableException $e) {
99			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s besitzt keinen Aktivierungsmodus[/color][/b]'), $ship->getName(), $systemName));
100			} catch (InsufficientEnergyException $e) {
101			$game->addInformation(sprintf(
102			_('%s: [b][color=#ff2626]System %s kann aufgrund Energiemangels (%d benötigt) nicht aktiviert werden[/color][/b]'),
103			$ship->getName(),
104			$systemName,
105			$e->getNeededEnergy()
106			));
107			} catch (SystemCooldownException $e) {
108			$game->addInformation(sprintf(
109			_('%s: [b][color=#ff2626]System %s kann nicht aktiviert werden, Cooldown noch %s[/color][/b]'),
110			$ship->getName(),
111			$systemName,
112			TalHelper::formatSeconds((string) $e->getRemainingSeconds())
113			));
114			} catch (SystemDamagedException $e) {
115			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s ist beschädigt und kann daher nicht aktiviert werden[/color][/b]'), $ship->getName(), $systemName));
116			} catch (ActivationConditionsNotMetException $e) {
117			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s konnte nicht aktiviert werden, weil %s[/color][/b]'), $ship->getName(), $systemName, $e->getMessage()));
118			} catch (SystemNotFoundException $e) {
119			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s nicht vorhanden[/color][/b]'), $ship->getName(), $systemName));
120			} catch (InsufficientCrewException $e) {
121			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s konnte wegen Mangel an Crew nicht aktiviert werden[/color][/b]'), $ship->getName(), $systemName));
122			} catch (ShipSystemException $e) {
123			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s konnte nicht aktiviert werden[/color][/b]'), $ship->getName(), $systemName));
124			}
125
126			return false;
127			}
128
129			public function activateFleet(
130			int $shipId,
131			int $systemId,
132			GameControllerInterface $game
133			): void {
134			$userId = $game->getUser()->getId();
135
136			$wrapper = $this->shipLoader->getWrapperByIdAndUser(
137			$shipId,
138			$userId
139			);
140
141			$fleetWrapper = $wrapper->getFleetWrapper();
142			if ($fleetWrapper === null) {
143			throw new RuntimeException('ship not in fleet');
144			}
145
146			$success = false;
147			foreach ($fleetWrapper->getShipWrappers() as $wrapper) {
148			if ($this->activateIntern($wrapper, $systemId, $game)) {
149			$success = true;
150			$this->shipRepository->save($wrapper->get());
151			}
152			}
153
154			// only show info if at least one ship was able to change
155			if (!$success) {
156			return;
157			}
158
159			$systemName = ShipSystemTypeEnum::getDescription($systemId);
160			$game->addInformation(sprintf(_('Flottenbefehl ausgeführt: System %s aktiviert'), $systemName));
161			}
162
163			public function deactivate(
164			int $shipId,
165			int $systemId,
166			GameControllerInterface $game,
167			bool $allowUplink = false
168			): bool {
169			$userId = $game->getUser()->getId();
170
171			$wrapper = $this->shipLoader->getWrapperByIdAndUser(
172			$shipId,
173			$userId,
174			$allowUplink
175			);
176
177			if ($this->deactivateIntern($wrapper, $systemId, $game)) {
178			$this->shipRepository->save($wrapper->get());
179			return true;
180			} else {
181			return false;
182			}
183			}
184
185			private function deactivateIntern(
186			ShipWrapperInterface $wrapper,
187			int $systemId,
188			GameControllerInterface $game
189			): bool {
190			$systemName = ShipSystemTypeEnum::getDescription($systemId);
191			$ship = $wrapper->get();
192
193			try {
194			$this->shipSystemManager->deactivate($wrapper, $systemId);
195			$game->addInformation(sprintf(_('%s: System %s deaktiviert'), $ship->getName(), $systemName));
196			return true;
197			} catch (AlreadyOffException $e) {
198			$game->addInformation(sprintf(_('%s: System %s ist bereits deaktiviert'), $ship->getName(), $systemName));
199			} catch (SystemNotDeactivatableException $e) {
200			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s besitzt keinen Deaktivierungsmodus[/color][/b]'), $ship->getName(), $systemName));
201			} catch (DeactivationConditionsNotMetException $e) {
202			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]System %s konnte nicht deaktiviert werden, weil %s[/color][/b]'), $ship->getName(), $systemName, $e->getMessage()));
203			} catch (SystemNotFoundException $e) {
204			$game->addInformation(sprintf(_('%s: System %s nicht vorhanden'), $ship->getName(), $systemName));
205			}
206
207			return false;
208			}
209
210			public function deactivateFleet(
211			int $shipId,
212			int $systemId,
213			GameControllerInterface $game
214			): void {
215			$userId = $game->getUser()->getId();
216
217			$wrapper = $this->shipLoader->getWrapperByIdAndUser(
218			$shipId,
219			$userId
220			);
221
222			$fleetWrapper = $wrapper->getFleetWrapper();
223			if ($fleetWrapper === null) {
224			throw new RuntimeException('ship not in fleet');
225			}
226
227			$success = false;
228			foreach ($fleetWrapper->getShipWrappers() as $wrapper) {
229			if ($this->deactivateIntern($wrapper, $systemId, $game)) {
230			$success = true;
231			$this->shipRepository->save($wrapper->get());
232			}
233			}
234
235			// only show info if at least one ship was able to change
236			if (!$success) {
237			return;
238			}
239
240			$systemName = ShipSystemTypeEnum::getDescription($systemId);
241			$game->addInformation(sprintf(_('Flottenbefehl ausgeführt: System %s deaktiviert'), $systemName));
242			}
243
244			public function setLSSMode(
245			int $shipId,
246			int $lssMode,
247			GameControllerInterface $game
248			): void {
249			$userId = $game->getUser()->getId();
250
251			$ship = $this->shipLoader->getByIdAndUser(
252			$shipId,
253			$userId
254			);
255
256			$ship->setLSSMode($lssMode);
257			$this->shipRepository->save($ship);
258
259			if ($lssMode === ShipLSSModeEnum::LSS_NORMAL) {
260			$game->addInformation("Territoriale Grenzanzeige deaktiviert");
261			} elseif ($lssMode === ShipLSSModeEnum::LSS_BORDER) {
262			$game->addInformation("Territoriale Grenzanzeige aktiviert");
263			}
264			}
265
266			public function setAlertState(
267			int $shipId,
268			int $alertState,
269			GameControllerInterface $game
270			): void {
271			$userId = $game->getUser()->getId();
272
273			$wrapper = $this->shipLoader->getWrapperByIdAndUser(
274			$shipId,
275			$userId
276			);
277
278			if (!$this->setAlertStateShip($wrapper, $alertState, $game)) {
279			return;
280			}
281
282			if ($alertState === ShipAlertStateEnum::ALERT_RED) {
283			$game->addInformation("Die Alarmstufe wurde auf [b][color=red]Rot[/color][/b] geändert");
284			} elseif ($alertState === ShipAlertStateEnum::ALERT_YELLOW) {
285			$game->addInformation("Die Alarmstufe wurde auf [b][color=yellow]Gelb[/color][/b] geändert");
286			} elseif ($alertState === ShipAlertStateEnum::ALERT_GREEN) {
287			$game->addInformation("Die Alarmstufe wurde auf [b][color=green]Grün[/color][/b] geändert");
288			}
289			}
290
291			public function setAlertStateFleet(
292			int $shipId,
293			int $alertState,
294			GameControllerInterface $game
295			): void {
296			$userId = $game->getUser()->getId();
297
298			$wrapper = $this->shipLoader->getWrapperByIdAndUser(
299			$shipId,
300			$userId
301			);
302
303			$fleetWrapper = $wrapper->getFleetWrapper();
304			if ($fleetWrapper === null) {
305			throw new RuntimeException('ship not in fleet');
306			}
307
308			$success = false;
309			foreach ($fleetWrapper->getShipWrappers() as $wrapper) {
310			$success = $this->setAlertStateShip($wrapper, $alertState, $game) \|\| $success;
311			}
312
313			// only show info if at least one ship was able to change
314			if (!$success) {
315			return;
316			}
317
318			if ($alertState === ShipAlertStateEnum::ALERT_RED) {
319			$game->addInformation(_('Flottenbefehl ausgeführt: Alarmstufe [b][color=red]Rot[/color][/b]'));
320			} elseif ($alertState === ShipAlertStateEnum::ALERT_YELLOW) {
321			$game->addInformation(_('Flottenbefehl ausgeführt: Alarmstufe [b][color=yellow]Gelb[/color][/b]'));
322			} elseif ($alertState === ShipAlertStateEnum::ALERT_GREEN) {
323			$game->addInformation(_('Flottenbefehl ausgeführt: Alarmstufe [b][color=green]Grün[/color][/b]'));
324			}
325			}
326
327			private function setAlertStateShip(ShipWrapperInterface $wrapper, int $alertState, GameControllerInterface $game): bool
328			{
329			$ship = $wrapper->get();
330
331			// station constructions can't change alert state
332			if ($ship->isConstruction()) {
333			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]Konstrukte können die Alarmstufe nicht ändern[/color][/b]'), $ship->getName()));
334			return false;
335			}
336
337			// can only change when there is enough crew
338			if (!$ship->hasEnoughCrew()) {
339			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]Mangel an Crew verhindert den Wechsel der Alarmstufe[/color][/b]'), $ship->getName()));
340			return false;
341			}
342
343			if ($alertState === ShipAlertStateEnum::ALERT_RED && $ship->getCloakState()) {
344			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]Tarnung verhindert den Wechsel zu Alarm-Rot[/color][/b]'), $ship->getName()));
345			return false;
346			}
347
348			try {
349			$alertMsg = $wrapper->setAlertState($alertState);
350			$this->shipRepository->save($ship);
351
352			if ($alertMsg !== null) {
353			$game->addInformation(sprintf(_('%s: [b][color=FAFA03]%s[/color][/b]'), $ship->getName(), $alertMsg));
354			}
355			} catch (InsufficientEnergyException $e) {
356			$game->addInformation(sprintf(_('%s: [b][color=#ff2626]Nicht genügend Energie um die Alarmstufe zu wechseln (%d benötigt)[/color][/b]'), $ship->getName(), $e->getNeededEnergy()));
357			return false;
358			}
359
360			switch ($alertState) {
361			case ShipAlertStateEnum::ALERT_RED:
362			$this->setAlertRed($wrapper, $game);
363			break;
364			case ShipAlertStateEnum::ALERT_YELLOW:
365			$this->setAlertYellow($wrapper, $game);
366			break;
367			case ShipAlertStateEnum::ALERT_GREEN:
368			$this->setAlertGreen($wrapper, $game);
369			break;
370			}
371
372			$this->shipRepository->save($ship);
373
374			return true;
375			}
376
377			private function setAlertRed(ShipWrapperInterface $wrapper, GameControllerInterface $game): void
378			{
379			$alertSystems = [
380			ShipSystemTypeEnum::SYSTEM_SHIELDS,
381			ShipSystemTypeEnum::SYSTEM_NBS,
382			ShipSystemTypeEnum::SYSTEM_PHASER,
383			ShipSystemTypeEnum::SYSTEM_TORPEDO
384			];
385
386			foreach ($alertSystems as $systemId) {
387			$this->activateIntern($wrapper, $systemId, $game);
388			}
389			}
390
391			private function setAlertYellow(ShipWrapperInterface $wrapper, GameControllerInterface $game): void
392			{
393			$alertSystems = [
394			ShipSystemTypeEnum::SYSTEM_NBS
395			];
396
397			foreach ($alertSystems as $systemId) {
398			$this->activateIntern($wrapper, $systemId, $game);
399			}
400			}
401
402			private function setAlertGreen(ShipWrapperInterface $wrapper, GameControllerInterface $game): void
403			{
404			$deactivateSystems = [
405			ShipSystemTypeEnum::SYSTEM_PHASER,
406			ShipSystemTypeEnum::SYSTEM_TORPEDO,
407			ShipSystemTypeEnum::SYSTEM_SHIELDS
408			];
409
410			foreach ($deactivateSystems as $systemId) {
411			if ($wrapper->get()->hasShipSystem($systemId)) {
412			$this->deactivateIntern($wrapper, $systemId, $game);
413			}
414			}
415			}
416
417			public function setWarpSplitFleet(
418			int $shipId,
419			GameControllerInterface $game
420			): void {
421			$userId = $game->getUser()->getId();
422
423			$wrapper = $this->shipLoader->getWrapperByIdAndUser(
424			$shipId,
425			$userId
426			);
427			$warpsplit = $wrapper->getWarpCoreSystemData()->getWarpCoreSplit();
428
429			$fleetWrapper = $wrapper->getFleetWrapper();
430			if ($fleetWrapper === null) {
431			throw new RuntimeException('ship not in fleet');
432			}
433
434			$success = false;
435			foreach ($fleetWrapper->getShipWrappers() as $wrapper) {
436			if ($wrapper->getWarpDriveSystemData() !== null) {
437			$success = true;
438			$wrapper->getWarpCoreSystemData()->setWarpCoreSplit($warpsplit)->update();
439			}
440			}
441
442			// only show info if at least one ship was able to change
443			if (!$success) {
444			return;
445			}
446
447
448			$game->addInformation(sprintf(_('Flottenbefehl ausgeführt: Warpkernsplit von %d Prozent auf Flotte angewendet'), $warpsplit));
449			}
450			}
451

st-universe / core

Push — master ( 6288df...4d55dd )

ActivatorDeactivatorHelper::setLSSMode() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like