ShipAttacker::__construct() - Code Metrics - Inspection of "log" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — dev ( 82c4ce...00c566 )

by Janko

created 2024-07-01 16:53 UTC

ShipAttacker::__construct() A

↳ Parent: ShipAttacker

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	0

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Stu\Module\Ship\Lib\Battle\Provider;

use RuntimeException;
use Stu\Component\Ship\System\ShipSystemTypeEnum;
use Stu\Module\Control\StuRandom;
use Stu\Module\Logging\LoggerUtilInterface;
use Stu\Module\Ship\Lib\ModuleValueCalculatorInterface;
use Stu\Module\Ship\Lib\ShipWrapperInterface;
use Stu\Module\Ship\Lib\Torpedo\ShipTorpedoManagerInterface;
use Stu\Orm\Entity\ModuleInterface;
use Stu\Orm\Entity\ShipInterface;
use Stu\Orm\Entity\TorpedoTypeInterface;
use Stu\Orm\Entity\UserInterface;

class ShipAttacker extends AbstractEnergyAttacker implements ProjectileAttackerInterface
{
    public function __construct(
        private ShipWrapperInterface $wrapper,
        private ModuleValueCalculatorInterface $moduleValueCalculator,
        private ShipTorpedoManagerInterface $shipTorpedoManager,
        private StuRandom $stuRandom,
        private LoggerUtilInterface $logger
    ) {
    }

    public function getPhaserVolleys(): int
    {
        return $this->get()->getRump()->getPhaserVolleys();
    }

    public function getPhaserState(): bool
    {
        return $this->get()->getPhaserState();
    }

    public function hasSufficientEnergy(int $amount): bool
    {
        $epsSystemData = $this->wrapper->getEpsSystemData();
        if ($epsSystemData === null) {
            return false;
        }
        return $epsSystemData->getEps() >= $amount;
    }

    public function getWeaponModule(): ModuleInterface
    {
        if ($this->module === null) {
            $shipSystem = $this->get()->getShipSystem(ShipSystemTypeEnum::SYSTEM_PHASER);

            $module = $shipSystem->getModule();
            if ($module === null) {
                throw new RuntimeException('weapon system should have a module');
            }

            $this->module = $module;
        }

        return $this->module;

    }

    public function getEnergyWeaponBaseDamage(): int
    {
        return $this->moduleValueCalculator->calculateModuleValue(
            $this->get()->getRump(),
            $this->getWeaponModule(),
            'getBaseDamage'
        );
    }

    public function reduceEps(int $amount): void
    {
        $epsSystemData = $this->wrapper->getEpsSystemData();
        if ($epsSystemData === null) {
            return;
        }
        $epsSystemData->lowerEps($amount)->update();
    }

    public function getName(): string
    {
        return $this->get()->getName();
    }

    public function getUser(): UserInterface
    {
        return $this->get()->getUser();
    }

    private function get(): ShipInterface
    {
        return $this->wrapper->get();
    }

    public function getHitChance(): int
    {
        return $this->get()->getHitChance();
    }

    public function getPhaserShieldDamageFactor(): int
    {
        return $this->get()->getRump()->getPhaserShieldDamageFactor();
    }

    public function getPhaserHullDamageFactor(): int
    {
        return $this->get()->getRump()->getPhaserHullDamageFactor();
    }

    public function getTorpedoVolleys(): int
    {
        return $this->get()->getRump()->getTorpedoVolleys();
    }

    public function getTorpedoState(): bool
    {
        return $this->get()->getTorpedoState();
    }

    public function getTorpedoCount(): int
    {
        return $this->get()->getTorpedoCount();
    }

    public function getTorpedo(): ?TorpedoTypeInterface
    {
        return $this->get()->getTorpedo();
    }

    public function lowerTorpedoCount(int $amount): void
    {
        $this->shipTorpedoManager->changeTorpedo($this->wrapper, -$amount);
    }

    public function isShieldPenetration(): bool
    {
        $systemData = $this->wrapper->getProjectileLauncherSystemData();
        if ($systemData === null) {
            throw new RuntimeException('this should not happen');
        }

        return $this->stuRandom->rand(1, 10000) <= $systemData->getShieldPenetration();
    }

    public function getProjectileWeaponDamage(bool $isCritical): int
    {
        $torpedo = $this->getTorpedo();
        if ($torpedo === null) {
            $this->logger->log('shipAttacker->getProjectileWeaponDamage: no torpedo');
            return 0;
        }

        $module = $this->get()->getShipSystem(ShipSystemTypeEnum::SYSTEM_TORPEDO)->getModule();
        if ($module === null) {
            $this->logger->log('shipAttacker->getProjectileWeaponDamage: no module');
            return 0;
        }

        $variance = (int) round($torpedo->getBaseDamage() / 100 * $torpedo->getVariance());
        $basedamage = $this->moduleValueCalculator->calculateModuleValue(
            $this->get()->getRump(),
            $module,
            false,
            $torpedo->getBaseDamage()
        );
        $damage = random_int($basedamage - $variance, $basedamage + $variance);

        if ($damage === 0) {
            $this->logger->logf(
                'shipAttacker->getProjectileWeaponDamage, baseDamage: %d',
                $torpedo->getBaseDamage()
            );
        }

        return $isCritical ? $damage * 2 : $damage;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Stu\Module\Ship\Lib\Battle\Provider;
6
7		use RuntimeException;
8		use Stu\Component\Ship\System\ShipSystemTypeEnum;
9		use Stu\Module\Control\StuRandom;
10		use Stu\Module\Logging\LoggerUtilInterface;
11		use Stu\Module\Ship\Lib\ModuleValueCalculatorInterface;
12		use Stu\Module\Ship\Lib\ShipWrapperInterface;
13		use Stu\Module\Ship\Lib\Torpedo\ShipTorpedoManagerInterface;
14		use Stu\Orm\Entity\ModuleInterface;
15		use Stu\Orm\Entity\ShipInterface;
16		use Stu\Orm\Entity\TorpedoTypeInterface;
17		use Stu\Orm\Entity\UserInterface;
18
19		class ShipAttacker extends AbstractEnergyAttacker implements ProjectileAttackerInterface
20		{
21	24	public function __construct(
22		private ShipWrapperInterface $wrapper,
23		private ModuleValueCalculatorInterface $moduleValueCalculator,
24		private ShipTorpedoManagerInterface $shipTorpedoManager,
25		private StuRandom $stuRandom,
26		private LoggerUtilInterface $logger
27		) {
28	24	}
29
30	1	public function getPhaserVolleys(): int
31		{
32	1	return $this->get()->getRump()->getPhaserVolleys();
33		}
34
35	1	public function getPhaserState(): bool
36		{
37	1	return $this->get()->getPhaserState();
38		}
39
40	3	public function hasSufficientEnergy(int $amount): bool
41		{
42	3	$epsSystemData = $this->wrapper->getEpsSystemData();
43	3	if ($epsSystemData === null) {
44	1	return false;
45		}
46	2	return $epsSystemData->getEps() >= $amount;
47		}
48
49	3	public function getWeaponModule(): ModuleInterface
50		{
51	3	if ($this->module === null) {
52	3	$shipSystem = $this->get()->getShipSystem(ShipSystemTypeEnum::SYSTEM_PHASER);
53
54	3	$module = $shipSystem->getModule();
55	3	if ($module === null) {
56	1	throw new RuntimeException('weapon system should have a module');
57		}
58
59	2	$this->module = $module;
60		}
61
62	2	return $this->module;
		0 ignored issues – show Bug Best Practice introduced 2023-11-28 21:50 UTC by Report Bug Copy Issue Report The expression `return $this->module` could return the type `null` which is incompatible with the type-hinted return `Stu\Orm\Entity\ModuleInterface`. Consider adding an additional type-check to rule them out. Loading history...
63		}
64
65	1	public function getEnergyWeaponBaseDamage(): int
66		{
67	1	return $this->moduleValueCalculator->calculateModuleValue(
68	1	$this->get()->getRump(),
69	1	$this->getWeaponModule(),
70	1	'getBaseDamage'
71	1	);
72		}
73
74	2	public function reduceEps(int $amount): void
75		{
76	2	$epsSystemData = $this->wrapper->getEpsSystemData();
77	2	if ($epsSystemData === null) {
78	1	return;
79		}
80	1	$epsSystemData->lowerEps($amount)->update();
81		}
82
83	1	public function getName(): string
84		{
85	1	return $this->get()->getName();
86		}
87
88	1	public function getUser(): UserInterface
89		{
90	1	return $this->get()->getUser();
91		}
92
93	17	private function get(): ShipInterface
94		{
95	17	return $this->wrapper->get();
96		}
97
98	1	public function getHitChance(): int
99		{
100	1	return $this->get()->getHitChance();
101		}
102
103	1	public function getPhaserShieldDamageFactor(): int
104		{
105	1	return $this->get()->getRump()->getPhaserShieldDamageFactor();
106		}
107
108	1	public function getPhaserHullDamageFactor(): int
109		{
110	1	return $this->get()->getRump()->getPhaserHullDamageFactor();
111		}
112
113	1	public function getTorpedoVolleys(): int
114		{
115	1	return $this->get()->getRump()->getTorpedoVolleys();
116		}
117
118	1	public function getTorpedoState(): bool
119		{
120	1	return $this->get()->getTorpedoState();
121		}
122
123	1	public function getTorpedoCount(): int
124		{
125	1	return $this->get()->getTorpedoCount();
126		}
127
128	4	public function getTorpedo(): ?TorpedoTypeInterface
129		{
130	4	return $this->get()->getTorpedo();
131		}
132
133	1	public function lowerTorpedoCount(int $amount): void
134		{
135	1	$this->shipTorpedoManager->changeTorpedo($this->wrapper, -$amount);
136		}
137
138		public function isShieldPenetration(): bool
139		{
140		$systemData = $this->wrapper->getProjectileLauncherSystemData();
141		if ($systemData === null) {
142		throw new RuntimeException('this should not happen');
143		}
144
145		return $this->stuRandom->rand(1, 10000) <= $systemData->getShieldPenetration();
146		}
147
148	3	public function getProjectileWeaponDamage(bool $isCritical): int
149		{
150	3	$torpedo = $this->getTorpedo();
151	3	if ($torpedo === null) {
152	1	$this->logger->log('shipAttacker->getProjectileWeaponDamage: no torpedo');
153	1	return 0;
154		}
155
156	2	$module = $this->get()->getShipSystem(ShipSystemTypeEnum::SYSTEM_TORPEDO)->getModule();
157	2	if ($module === null) {
158	1	$this->logger->log('shipAttacker->getProjectileWeaponDamage: no module');
159	1	return 0;
160		}
161
162	1	$variance = (int) round($torpedo->getBaseDamage() / 100 * $torpedo->getVariance());
163	1	$basedamage = $this->moduleValueCalculator->calculateModuleValue(
164	1	$this->get()->getRump(),
165	1	$module,
166	1	false,
167	1	$torpedo->getBaseDamage()
168	1	);
169	1	$damage = random_int($basedamage - $variance, $basedamage + $variance);
170
171	1	if ($damage === 0) {
172		$this->logger->logf(
173		'shipAttacker->getProjectileWeaponDamage, baseDamage: %d',
174		$torpedo->getBaseDamage()
175		);
176		}
177
178	1	return $isCritical ? $damage * 2 : $damage;
179		}
180		}
181

st-universe / core

Push — dev ( 82c4ce...00c566 )

ShipAttacker::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like