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

Passed

Push — dev ( 501ee6...82c4ce )

by Janko

created 2024-07-01 15:41 UTC

ApplyDamage::destroyRandomShipSystem() A

↳ Parent: ApplyDamage

Complexity

Conditions	2
Paths	2

Size

Total Lines	14
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Stu\Module\Ship\Lib\Damage;

use RuntimeException;
use Stu\Component\Ship\ShipEnum;
use Stu\Component\Ship\System\ShipSystemManagerInterface;
use Stu\Component\Ship\System\ShipSystemModeEnum;
use Stu\Component\Ship\System\ShipSystemTypeEnum;
use Stu\Lib\DamageWrapper;
use Stu\Lib\Information\InformationInterface;
use Stu\Lib\Information\InformationWrapper;
use Stu\Module\Colony\Lib\ColonyLibFactoryInterface;
use Stu\Module\Ship\Lib\ShipWrapperInterface;
use Stu\Orm\Entity\ColonyInterface;
use Stu\Orm\Entity\PlanetFieldInterface;
use Stu\Orm\Entity\ShipSystemInterface;

//TODO unit tests and move to Lib/Damage
final class ApplyDamage implements ApplyDamageInterface
{
    public function __construct(
        private ColonyLibFactoryInterface $colonyLibFactory,
        private ShipSystemManagerInterface $shipSystemManager
    ) {
    }

    public function damage(
        DamageWrapper $damageWrapper,
        ShipWrapperInterface $shipWrapper
    ): InformationWrapper {

        if ($damageWrapper->getNetDamage() <= 0) {
            throw new RuntimeException('this should not happen');
        }


        $ship = $shipWrapper->get();
        $ship->setShieldRegenerationTimer(time());

        $informations = new InformationWrapper();
        if ($ship->getShieldState()) {

            if ($damageWrapper->isShieldPenetration()) {
                $informations->addInformationf('- Projektil hat Schilde durchdrungen!');
            } else {
                $this->damageShields($shipWrapper, $damageWrapper, $informations);
            }
        }
        if ($damageWrapper->getNetDamage() <= 0) {
            return $informations;
        }

        $disablemessage = false;
        $damage = (int) $damageWrapper->getDamageRelative($ship, ShipEnum::DAMAGE_MODE_HULL);
        if ($ship->getSystemState(ShipSystemTypeEnum::SYSTEM_RPG_MODULE) && $ship->getHull() - $damage < round($ship->getMaxHull() / 100 * 10)) {
            $damage = (int) round($ship->getHull() - $ship->getMaxHull() / 100 * 10);
            $disablemessage = _('-- Das Schiff wurde kampfunfähig gemacht');
            $ship->setDisabled(true);
        }
        if ($ship->getHull() > $damage) {
            if ($damageWrapper->isCrit()) {
                $systemName = $this->destroyRandomShipSystem($shipWrapper);

                if ($systemName !== null) {
                    $informations->addInformation("- Kritischer Hüllen-Treffer zerstört System: " . $systemName);
                }
            }
            $huelleVorher = $ship->getHull();
            $ship->setHuell($huelleVorher - $damage);
            $informations->addInformation("- Hüllenschaden: " . $damage . " - Status: " . $ship->getHull());

            if (!$this->checkForDamagedShipSystems(
                $shipWrapper,
                $huelleVorher,
                $informations
            )) {
                $this->damageRandomShipSystem(
                    $shipWrapper,
                    $informations,
                    (int)ceil((100 * $damage * random_int(1, 5)) / $ship->getMaxHull())
                );
            }

            if ($disablemessage) {
                $informations->addInformation($disablemessage);
            }

            if ($ship->isDestroyed()) {
                $informations->addInformation("-- Das Schiff wurde zerstört!");
            }

            return $informations;
        }
        $informations->addInformation("- Hüllenschaden: " . $damage);
        $informations->addInformation("-- Das Schiff wurde zerstört!");
        $ship->setIsDestroyed(true);

        return $informations;
    }

    private function damageShields(ShipWrapperInterface $wrapper, DamageWrapper $damageWrapper, InformationInterface $informations): void
    {
        $ship = $wrapper->get();

        $damage = (int) $damageWrapper->getDamageRelative($ship, ShipEnum::DAMAGE_MODE_SHIELDS);
        if ($damage >= $ship->getShield()) {
            $informations->addInformation("- Schildschaden: " . $ship->getShield());
            $informations->addInformation("-- Schilde brechen zusammen!");

            $this->shipSystemManager->deactivate($wrapper, ShipSystemTypeEnum::SYSTEM_SHIELDS);

            $ship->setShield(0);
        } else {
            $ship->setShield($ship->getShield() - $damage);
            $informations->addInformation("- Schildschaden: " . $damage . " - Status: " . $ship->getShield());
        }
    }

    public function damageBuilding(
        DamageWrapper $damageWrapper,
        PlanetFieldInterface $target,
        bool $isOrbitField
    ): InformationWrapper {
        $informations = new InformationWrapper();

        $colony = $target->getHost();
        if (!$colony instanceof ColonyInterface) {
            throw new RuntimeException('this should not happen');
        }

        if (!$isOrbitField && $this->colonyLibFactory->createColonyShieldingManager($colony)->isShieldingEnabled()) {
            $damage = (int) $damageWrapper->getDamageRelative($colony, ShipEnum::DAMAGE_MODE_SHIELDS);
            if ($damage > $colony->getShields()) {
                $informations->addInformation("- Schildschaden: " . $colony->getShields());
                $informations->addInformation("-- Schilde brechen zusammen!");

                $colony->setShields(0);
            } else {
                $colony->setShields($colony->getShields() - $damage);
                $informations->addInformation("- Schildschaden: " . $damage . " - Status: " . $colony->getShields());
            }
        }
        if ($damageWrapper->getNetDamage() <= 0) {
            return $informations;
        }
        $damage = (int) $damageWrapper->getDamageRelative($colony, ShipEnum::DAMAGE_MODE_HULL);
        if ($target->getIntegrity() > $damage) {
            $target->setIntegrity($target->getIntegrity() - $damage);
            $informations->addInformation("- Gebäudeschaden: " . $damage . " - Status: " . $target->getIntegrity());

            return $informations;
        }
        $informations->addInformation("- Gebäudeschaden: " . $damage);
        $informations->addInformation("-- Das Gebäude wurde zerstört!");
        $target->setIntegrity(0);

        return $informations;
    }

    private function checkForDamagedShipSystems(
        ShipWrapperInterface $wrapper,
        int $huelleVorher,
        InformationWrapper $informations
    ): bool {
        $ship = $wrapper->get();
        $systemsToDamage = ceil($huelleVorher * 6 / $ship->getMaxHull()) -
            ceil($ship->getHull() * 6 / $ship->getMaxHull());

        if ($systemsToDamage == 0) {
            return false;
        }

        for ($i = 1; $i <= $systemsToDamage; $i++) {
            $this->damageRandomShipSystem($wrapper, $informations);
        }

        return true;
    }

    private function destroyRandomShipSystem(ShipWrapperInterface $wrapper): ?string
    {
        $healthySystems = $wrapper->get()->getHealthySystems();
        shuffle($healthySystems);

        if ($healthySystems === []) {
            return null;
        }
        $system = $healthySystems[0];
        $system->setStatus(0);
        $system->setMode(ShipSystemModeEnum::MODE_OFF);
        $this->shipSystemManager->handleDestroyedSystem($wrapper, $healthySystems[0]->getSystemType());

        return $healthySystems[0]->getSystemType()->getDescription();
    }

    private function damageRandomShipSystem(
        ShipWrapperInterface $wrapper,
        InformationWrapper $informations,
        int $percent = null
    ): void {
        $healthySystems = $wrapper->get()->getHealthySystems();
        shuffle($healthySystems);

        if ($healthySystems !== []) {
            $system = $healthySystems[0];

            $this->damageShipSystem($wrapper, $system, $percent ?? random_int(1, 70), $informations);
        }
    }

    public function damageShipSystem(
        ShipWrapperInterface $wrapper,
        ShipSystemInterface $system,
        int $dmg,
        InformationWrapper $informations
    ): bool {
        $status = $system->getStatus();
        $systemName = $system->getSystemType()->getDescription();

        if ($status > $dmg) {
            $system->setStatus($status - $dmg);
            $this->shipSystemManager->handleDamagedSystem($wrapper, $system->getSystemType());
            $informations->addInformation("- Folgendes System wurde beschädigt: " . $systemName);

            return false;
        } else {
            $system->setStatus(0);
            $system->setMode(ShipSystemModeEnum::MODE_OFF);
            $this->shipSystemManager->handleDestroyedSystem($wrapper, $system->getSystemType());
            $informations->addInformation("- Der Schaden zerstört folgendes System: " . $systemName);

            return true;
        }
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Stu\Module\Ship\Lib\Damage;
6
7		use RuntimeException;
8		use Stu\Component\Ship\ShipEnum;
9		use Stu\Component\Ship\System\ShipSystemManagerInterface;
10		use Stu\Component\Ship\System\ShipSystemModeEnum;
11		use Stu\Component\Ship\System\ShipSystemTypeEnum;
12		use Stu\Lib\DamageWrapper;
13		use Stu\Lib\Information\InformationInterface;
14		use Stu\Lib\Information\InformationWrapper;
15		use Stu\Module\Colony\Lib\ColonyLibFactoryInterface;
16		use Stu\Module\Ship\Lib\ShipWrapperInterface;
17		use Stu\Orm\Entity\ColonyInterface;
18		use Stu\Orm\Entity\PlanetFieldInterface;
19		use Stu\Orm\Entity\ShipSystemInterface;
20
21		//TODO unit tests and move to Lib/Damage
22		final class ApplyDamage implements ApplyDamageInterface
23		{
24	2	public function __construct(
25		private ColonyLibFactoryInterface $colonyLibFactory,
26		private ShipSystemManagerInterface $shipSystemManager
27		) {
28	2	}
29
30		public function damage(
31		DamageWrapper $damageWrapper,
32		ShipWrapperInterface $shipWrapper
33		): InformationWrapper {
34
35		if ($damageWrapper->getNetDamage() <= 0) {
36		throw new RuntimeException('this should not happen');
37		}
38
39
40		$ship = $shipWrapper->get();
41		$ship->setShieldRegenerationTimer(time());
42
43		$informations = new InformationWrapper();
44		if ($ship->getShieldState()) {
45
46		if ($damageWrapper->isShieldPenetration()) {
47		$informations->addInformationf('- Projektil hat Schilde durchdrungen!');
48		} else {
49		$this->damageShields($shipWrapper, $damageWrapper, $informations);
50		}
51		}
52		if ($damageWrapper->getNetDamage() <= 0) {
53		return $informations;
54		}
55
56		$disablemessage = false;
57		$damage = (int) $damageWrapper->getDamageRelative($ship, ShipEnum::DAMAGE_MODE_HULL);
58		if ($ship->getSystemState(ShipSystemTypeEnum::SYSTEM_RPG_MODULE) && $ship->getHull() - $damage < round($ship->getMaxHull() / 100 * 10)) {
59		$damage = (int) round($ship->getHull() - $ship->getMaxHull() / 100 * 10);
60		$disablemessage = _('-- Das Schiff wurde kampfunfähig gemacht');
61		$ship->setDisabled(true);
62		}
63		if ($ship->getHull() > $damage) {
64		if ($damageWrapper->isCrit()) {
65		$systemName = $this->destroyRandomShipSystem($shipWrapper);
66
67		if ($systemName !== null) {
68		$informations->addInformation("- Kritischer Hüllen-Treffer zerstört System: " . $systemName);
69		}
70		}
71		$huelleVorher = $ship->getHull();
72		$ship->setHuell($huelleVorher - $damage);
73		$informations->addInformation("- Hüllenschaden: " . $damage . " - Status: " . $ship->getHull());
74
75		if (!$this->checkForDamagedShipSystems(
76		$shipWrapper,
77		$huelleVorher,
78		$informations
79		)) {
80		$this->damageRandomShipSystem(
81		$shipWrapper,
82		$informations,
83		(int)ceil((100 * $damage * random_int(1, 5)) / $ship->getMaxHull())
84		);
85		}
86
87		if ($disablemessage) {
88		$informations->addInformation($disablemessage);
89		}
90
91		if ($ship->isDestroyed()) {
92		$informations->addInformation("-- Das Schiff wurde zerstört!");
93		}
94
95		return $informations;
96		}
97		$informations->addInformation("- Hüllenschaden: " . $damage);
98		$informations->addInformation("-- Das Schiff wurde zerstört!");
99		$ship->setIsDestroyed(true);
100
101		return $informations;
102		}
103
104		private function damageShields(ShipWrapperInterface $wrapper, DamageWrapper $damageWrapper, InformationInterface $informations): void
105		{
106		$ship = $wrapper->get();
107
108		$damage = (int) $damageWrapper->getDamageRelative($ship, ShipEnum::DAMAGE_MODE_SHIELDS);
109		if ($damage >= $ship->getShield()) {
110		$informations->addInformation("- Schildschaden: " . $ship->getShield());
111		$informations->addInformation("-- Schilde brechen zusammen!");
112
113		$this->shipSystemManager->deactivate($wrapper, ShipSystemTypeEnum::SYSTEM_SHIELDS);
114
115		$ship->setShield(0);
116		} else {
117		$ship->setShield($ship->getShield() - $damage);
118		$informations->addInformation("- Schildschaden: " . $damage . " - Status: " . $ship->getShield());
119		}
120		}
121
122		public function damageBuilding(
123		DamageWrapper $damageWrapper,
124		PlanetFieldInterface $target,
125		bool $isOrbitField
126		): InformationWrapper {
127		$informations = new InformationWrapper();
128
129		$colony = $target->getHost();
130		if (!$colony instanceof ColonyInterface) {
131		throw new RuntimeException('this should not happen');
132		}
133
134		if (!$isOrbitField && $this->colonyLibFactory->createColonyShieldingManager($colony)->isShieldingEnabled()) {
135		$damage = (int) $damageWrapper->getDamageRelative($colony, ShipEnum::DAMAGE_MODE_SHIELDS);
136		if ($damage > $colony->getShields()) {
137		$informations->addInformation("- Schildschaden: " . $colony->getShields());
138		$informations->addInformation("-- Schilde brechen zusammen!");
139
140		$colony->setShields(0);
141		} else {
142		$colony->setShields($colony->getShields() - $damage);
143		$informations->addInformation("- Schildschaden: " . $damage . " - Status: " . $colony->getShields());
144		}
145		}
146		if ($damageWrapper->getNetDamage() <= 0) {
147		return $informations;
148		}
149		$damage = (int) $damageWrapper->getDamageRelative($colony, ShipEnum::DAMAGE_MODE_HULL);
150		if ($target->getIntegrity() > $damage) {
151		$target->setIntegrity($target->getIntegrity() - $damage);
152		$informations->addInformation("- Gebäudeschaden: " . $damage . " - Status: " . $target->getIntegrity());
153
154		return $informations;
155		}
156		$informations->addInformation("- Gebäudeschaden: " . $damage);
157		$informations->addInformation("-- Das Gebäude wurde zerstört!");
158		$target->setIntegrity(0);
159
160		return $informations;
161		}
162
163		private function checkForDamagedShipSystems(
164		ShipWrapperInterface $wrapper,
165		int $huelleVorher,
166		InformationWrapper $informations
167		): bool {
168		$ship = $wrapper->get();
169		$systemsToDamage = ceil($huelleVorher * 6 / $ship->getMaxHull()) -
170		ceil($ship->getHull() * 6 / $ship->getMaxHull());
171
172		if ($systemsToDamage == 0) {
173		return false;
174		}
175
176		for ($i = 1; $i <= $systemsToDamage; $i++) {
177		$this->damageRandomShipSystem($wrapper, $informations);
178		}
179
180		return true;
181		}
182
183		private function destroyRandomShipSystem(ShipWrapperInterface $wrapper): ?string
184		{
185		$healthySystems = $wrapper->get()->getHealthySystems();
186		shuffle($healthySystems);
187
188		if ($healthySystems === []) {
189		return null;
190		}
191		$system = $healthySystems[0];
192		$system->setStatus(0);
193		$system->setMode(ShipSystemModeEnum::MODE_OFF);
194		$this->shipSystemManager->handleDestroyedSystem($wrapper, $healthySystems[0]->getSystemType());
195
196		return $healthySystems[0]->getSystemType()->getDescription();
197		}
198
199		private function damageRandomShipSystem(
200		ShipWrapperInterface $wrapper,
201		InformationWrapper $informations,
202		int $percent = null
203		): void {
204		$healthySystems = $wrapper->get()->getHealthySystems();
205		shuffle($healthySystems);
206
207		if ($healthySystems !== []) {
208		$system = $healthySystems[0];
209
210		$this->damageShipSystem($wrapper, $system, $percent ?? random_int(1, 70), $informations);
211		}
212		}
213
214		public function damageShipSystem(
215		ShipWrapperInterface $wrapper,
216		ShipSystemInterface $system,
217		int $dmg,
218		InformationWrapper $informations
219		): bool {
220		$status = $system->getStatus();
221		$systemName = $system->getSystemType()->getDescription();
222
223		if ($status > $dmg) {
224		$system->setStatus($status - $dmg);
225		$this->shipSystemManager->handleDamagedSystem($wrapper, $system->getSystemType());
226		$informations->addInformation("- Folgendes System wurde beschädigt: " . $systemName);
227
228		return false;
229		} else {
230		$system->setStatus(0);
231		$system->setMode(ShipSystemModeEnum::MODE_OFF);
232		$this->shipSystemManager->handleDestroyedSystem($wrapper, $system->getSystemType());
233		$informations->addInformation("- Der Schaden zerstört folgendes System: " . $systemName);
234
235		return true;
236		}
237		}
238		}
239

st-universe / core

Push — dev ( 501ee6...82c4ce )

ApplyDamage::destroyRandomShipSystem() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like