Stu\Orm\Entity\Spacecraft

Complexity

Total Complexity

234

Size/Duplication

Total Lines	1412
Duplicated Lines	0 %

Test Coverage

Coverage

60%

Importance

Changes

0

161 Methods

Rating	Name	Duplication	Size	Complexity
A	getName()	0	4	1
A	__construct()	0	6	1
A	setName()	0	5	1
A	getAlertState()	0	4	1
A	isSystemHealthy()	0	8	2
A	getSystemsId()	0	4	2
A	getUserName()	0	4	1
A	getFlightDirection()	0	4	1
A	getId()	0	8	2
A	getUserId()	0	4	1
A	getLssMode()	0	4	1
A	setLssMode()	0	5	1
A	setAlertStateGreen()	0	4	1
A	setFlightDirection()	0	5	1
A	setAlertState()	0	5	1
A	getLayer()	0	4	1
A	hasEnoughCrew()	0	23	6
A	isMatrixScannerHealthy()	0	4	1
A	isOverSystem()	0	9	2
A	getSectorString()	0	4	1
A	canMan()	0	8	3
A	hasCrewmanOfUser()	0	10	3
A	setLocation()	0	6	1
A	isAlertGreen()	0	4	1
A	getCloakState()	0	4	1
A	setSensorRange()	0	5	1
A	getRumpName()	0	4	1
A	getPosX()	0	4	1
A	setHoldingWeb()	0	10	2
A	isWarpPossible()	0	4	2
A	hasSubspaceScanner()	0	4	1
A	setIsInEmergency()	0	5	1
A	getWarpDriveState()	0	4	1
A	getLogbook()	0	4	1
A	setTakeoverPassive()	0	6	1
A	getTakeoverActive()	0	4	1
A	getColorStyle()	0	24	5
A	getTachyonState()	0	4	1
A	getHitChance()	0	9	2
A	getTorpedo()	0	8	2
A	getNbs()	0	4	1
A	getModules()	0	17	4
A	getSensorRange()	0	9	2
A	isShuttle()	0	4	1
A	isTractorbeamPossible()	0	4	1
A	hasShipSystem()	0	4	1
A	getShieldRegenerationRate()	0	4	1
A	getStoredShuttles()	0	12	3
A	getExcessCrewCount()	0	4	1
A	canIntercept()	0	6	4
A	getShield()	0	4	1
A	canMove()	0	5	2
A	getRump()	0	4	1
A	getCrewCount()	0	4	1
A	getLss()	0	4	1
A	getState()	0	4	1
A	getShieldRegenerationPercentage()	0	3	2
A	isShuttleRampHealthy()	0	4	1
A	hasStoredBuoy()	0	4	1
A	getBeamableStorage()	0	4	1
A	setHitChance()	0	5	1
A	setTakeoverActive()	0	6	1
A	setShieldRegenerationTimer()	0	5	1
A	isDisabled()	0	4	1
A	getStorageSum()	0	7	1
A	getSystemState()	0	8	2
A	hasPhaser()	0	4	1
A	getRepairRate()	0	5	1
A	setBuildplan()	0	5	1
A	getTractoredShip()	0	4	1
A	isInterceptable()	0	5	1
A	getStorage()	0	4	1
A	hasTranswarp()	0	4	1
A	isWarpAble()	0	4	1
A	setTractoredShip()	0	5	1
A	setShield()	0	5	1
A	__toString()	0	8	2
A	getBuildplan()	0	4	1
A	isTroopQuartersHealthy()	0	4	1
A	isOverColony()	0	4	2
A	hasUplink()	0	4	1
A	setHuell()	0	5	1
A	hasWarpdrive()	0	4	1
A	getUser()	0	4	1
A	getShieldRegenerationTimer()	0	4	1
A	hasFreeShuttleSpace()	0	9	3
A	getRumpId()	0	4	1
A	getTakeoverPassive()	0	4	1
A	getCrewAssignments()	0	4	1
A	hasEscapePods()	0	4	2
A	getImpulseState()	0	4	1
A	isBoardingPossible()	0	4	1
A	getTranswarpCooldown()	0	6	2
A	hasCloak()	0	4	1
A	setTractoredShipId()	0	5	1
A	getTorpedoCount()	0	8	2
A	setIsDestroyed()	0	5	1
A	getStoredShuttleCount()	0	12	3
A	isConstruction()	0	4	1
A	isDeflectorHealthy()	0	4	1
A	setDisabled()	0	5	1
A	getHealthySystems()	0	10	3
A	setEvadeChance()	0	5	1
A	getHull()	0	4	1
A	getShieldState()	0	4	1
A	hasTorpedo()	0	4	1
A	getDatabaseId()	0	4	1
A	getLocation()	0	11	3
A	getIsInEmergency()	0	4	1
A	setMaxHuell()	0	5	1
A	getHullColorStyle()	0	4	1
A	getRPGModuleState()	0	4	1
A	isWarped()	0	4	1
A	getMaxStorage()	0	4	1
A	getMap()	0	11	3
A	isUnderRepair()	0	5	2
A	getHoldingWebBackgroundStyle()	0	16	4
A	getHealthPercentage()	0	5	1
A	setBaseDamage()	0	5	1
A	getPhaserState()	0	4	1
A	setTorpedoStorage()	0	5	1
A	setUser()	0	5	1
A	getMapRegion()	0	14	3
A	getSystem()	0	4	2
A	hasTachyonScanner()	0	4	1
A	getSubspaceState()	0	4	1
A	isDestroyed()	0	4	1
A	setDatabaseId()	0	5	1
A	getNeededCrewCount()	0	9	2
A	hasNbsLss()	0	4	1
A	getPosY()	0	4	1
A	hasAstroLaboratory()	0	4	1
A	getMaxShield()	0	9	3
A	getHref()	0	8	1
A	getMaxHull()	0	4	1
A	setState()	0	5	1
A	isTorpedoStorageHealthy()	0	4	1
A	getMaxTorpedos()	0	6	2
A	getStoredBuoy()	0	12	3
A	getBeamFactor()	0	4	1
A	setMaxShield()	0	5	1
A	getTorpedoStorage()	0	4	1
A	getBaseDamage()	0	9	2
A	getEvadeChance()	0	9	2
A	getStarsystemMap()	0	8	2
A	displayNbsActions()	0	5	2
A	setRump()	0	5	1
A	getTractorPayload()	0	9	2
A	getHoldingWebImageStyle()	0	15	4
A	getHoldingWeb()	0	4	1
A	getWebState()	0	4	1
A	isWebEmitterHealthy()	0	4	1
A	hasActiveWeapon()	0	4	2
A	hasReactor()	0	6	3
A	isStation()	0	4	1
A	getTorpedoState()	0	4	1
A	hasShuttleRamp()	0	4	1
A	getShipSystem()	0	9	2
A	hasRPGModule()	0	4	1
A	isTractoring()	0	4	1
A	getSystems()	0	4	1

<?php

declare(strict_types=1);

namespace Stu\Orm\Entity;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping\Column;
use Doctrine\ORM\Mapping\DiscriminatorColumn;
use Doctrine\ORM\Mapping\DiscriminatorMap;
use Doctrine\ORM\Mapping\Entity;
use Doctrine\ORM\Mapping\GeneratedValue;
use Doctrine\ORM\Mapping\Id;
use Doctrine\ORM\Mapping\InheritanceType;
use Doctrine\ORM\Mapping\JoinColumn;
use Doctrine\ORM\Mapping\ManyToOne;
use Doctrine\ORM\Mapping\OneToMany;
use Doctrine\ORM\Mapping\OneToOne;
use Doctrine\ORM\Mapping\OrderBy;
use Doctrine\ORM\Mapping\Table;
use Override;

The type Override was not found. Maybe you did not declare it correctly or list all dependencies?

use RuntimeException;
use Stu\Component\Game\TimeConstants;

The type Stu\Component\Game\TimeConstants was not found. Maybe you did not declare it correctly or list all dependencies?

use Stu\Component\Map\DirectionEnum;
use Stu\Component\Spacecraft\SpacecraftAlertStateEnum;
use Stu\Component\Spacecraft\SpacecraftModuleTypeEnum;
use Stu\Component\Spacecraft\SpacecraftRumpEnum;

The type Stu\Component\Spacecraft\SpacecraftRumpEnum was not found. Maybe you did not declare it correctly or list all dependencies?

use Stu\Component\Spacecraft\SpacecraftStateEnum;
use Stu\Component\Spacecraft\SpacecraftLssModeEnum;
use Stu\Component\Spacecraft\SpacecraftTypeEnum;
use Stu\Component\Spacecraft\System\SpacecraftSystemModeEnum;
use Stu\Component\Spacecraft\System\SpacecraftSystemTypeEnum;
use Stu\Component\Spacecraft\System\Type\TorpedoStorageShipSystem;

The type Stu\Component\Spacecraft\System\Type\TorpedoStorageShipSystem was not found. Maybe you did not declare it correctly or list all dependencies?

use Stu\Component\Spacecraft\System\Type\TractorBeamShipSystem;
use Stu\Lib\Transfer\CommodityTransfer;
use Stu\Module\Control\GameControllerInterface;
use Stu\Module\Logging\LoggerUtilInterface;
use Stu\Module\Spacecraft\Lib\Battle\FightLib;
use Stu\Orm\Repository\SpacecraftRepository;

#[Table(name: 'stu_spacecraft')]
#[Entity(repositoryClass: SpacecraftRepository::class)]
#[InheritanceType('JOINED')]
#[DiscriminatorColumn(name: 'type', type: 'string')]
#[DiscriminatorMap([
    SpacecraftTypeEnum::SHIP->value => Ship::class,
    SpacecraftTypeEnum::STATION->value => Station::class
])]
abstract class Spacecraft implements SpacecraftInterface
{
    #[Id]
    #[Column(type: 'integer')]
    #[GeneratedValue(strategy: 'IDENTITY')]
    private ?int $id = null;

    #[Column(type: 'integer')]
    private int $user_id = 0;

    #[Column(type: 'integer')]
    private int $rump_id = 0;

The private property $rump_id is not used, and could be removed.

    #[Column(type: 'integer', nullable: true)]
    private ?int $plan_id = null;

The private property $plan_id is not used, and could be removed.

    #[Column(type: 'smallint', length: 1, enumType: DirectionEnum::class, nullable: true)]
    private ?DirectionEnum $direction = null;

    #[Column(type: 'string')]
    private string $name = '';

    #[Column(type: 'smallint', length: 1, enumType: SpacecraftAlertStateEnum::class)]
    private SpacecraftAlertStateEnum $alvl = SpacecraftAlertStateEnum::ALERT_GREEN;

    #[Column(type: 'smallint', length: 1, enumType: SpacecraftLssModeEnum::class)]
    private SpacecraftLssModeEnum $lss_mode = SpacecraftLssModeEnum::LSS_NORMAL;

    #[Column(type: 'integer', length: 6)]
    private int $huelle = 0;

    #[Column(type: 'integer', length: 6)]
    private int $max_huelle = 0;

    #[Column(type: 'integer', length: 6)]
    private int $schilde = 0;

    #[Column(type: 'integer', length: 6)]
    private int $max_schilde = 0;

    #[Column(type: 'integer', nullable: true)]
    private ?int $tractored_ship_id = null;

    #[Column(type: 'integer', nullable: true)]
    private ?int $holding_web_id = null;

    #[Column(type: 'integer', nullable: true)]
    private ?int $database_id = null;

    private bool $is_destroyed = false;

    #[Column(type: 'boolean')]
    private bool $disabled = false;

    #[Column(type: 'smallint', length: 3)]
    private int $hit_chance = 0;

    #[Column(type: 'smallint', length: 3)]
    private int $evade_chance = 0;

    #[Column(type: 'smallint', length: 4)]
    private int $base_damage = 0;

    #[Column(type: 'smallint', length: 3)]
    private int $sensor_range = 0;

    #[Column(type: 'integer')]
    private int $shield_regeneration_timer = 0;

    #[Column(type: 'smallint', enumType: SpacecraftStateEnum::class)]
    private SpacecraftStateEnum $state = SpacecraftStateEnum::SHIP_STATE_NONE;

    #[Column(type: 'integer')]
    private int $location_id = 0;

The private property $location_id is not used, and could be removed.

    #[Column(type: 'boolean')]
    private bool $in_emergency = false;

    #[OneToOne(targetEntity: 'Ship')]
    #[JoinColumn(name: 'tractored_ship_id', referencedColumnName: 'id')]
    private ?ShipInterface $tractoredShip = null;

    #[ManyToOne(targetEntity: 'TholianWeb')]
    #[JoinColumn(name: 'holding_web_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
    private ?TholianWebInterface $holdingWeb = null;

    #[ManyToOne(targetEntity: 'User')]
    #[JoinColumn(name: 'user_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
    private UserInterface $user;

    /**
     * @var ArrayCollection<int, CrewAssignmentInterface>
     */
    #[OneToMany(targetEntity: 'CrewAssignment', mappedBy: 'spacecraft', indexBy: 'id')]
    #[OrderBy(['id' => 'ASC'])]
    private Collection $crew;

    #[OneToOne(targetEntity: 'TorpedoStorage', mappedBy: 'spacecraft')]
    private ?TorpedoStorageInterface $torpedoStorage = null;

    /**
     * @var ArrayCollection<int, SpacecraftSystemInterface>
     */
    #[OneToMany(targetEntity: 'SpacecraftSystem', mappedBy: 'spacecraft', indexBy: 'system_type')]
    #[OrderBy(['system_type' => 'ASC'])]
    private Collection $systems;

    #[ManyToOne(targetEntity: 'SpacecraftRump')]
    #[JoinColumn(name: 'rump_id', referencedColumnName: 'id')]
    private SpacecraftRumpInterface $rump;

    #[ManyToOne(targetEntity: 'SpacecraftBuildplan')]
    #[JoinColumn(name: 'plan_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
    private ?SpacecraftBuildplanInterface $buildplan = null;

    /**
     * @var ArrayCollection<int, StorageInterface>
     */
    #[OneToMany(targetEntity: 'Storage', mappedBy: 'spacecraft', indexBy: 'commodity_id')]
    #[OrderBy(['commodity_id' => 'ASC'])]
    private Collection $storage;

    #[ManyToOne(targetEntity: 'Location')]
    #[JoinColumn(name: 'location_id', referencedColumnName: 'id')]
    private LocationInterface $location;

    /**
     * @var ArrayCollection<int, ShipLogInterface>
     */
    #[OneToMany(targetEntity: 'ShipLog', mappedBy: 'spacecraft', fetch: 'EXTRA_LAZY')]
    #[OrderBy(['id' => 'DESC'])]
    private Collection $logbook;

    #[OneToOne(targetEntity: 'ShipTakeover', mappedBy: 'source')]
    private ?ShipTakeoverInterface $takeoverActive = null;

    #[OneToOne(targetEntity: 'ShipTakeover', mappedBy: 'target')]
    private ?ShipTakeoverInterface $takeoverPassive = null;

    public function __construct()
    {
        $this->crew = new ArrayCollection();
        $this->systems = new ArrayCollection();
        $this->storage = new ArrayCollection();
        $this->logbook = new ArrayCollection();
    }

    #[Override]
    public function getId(): int
    {
        if ($this->id === null) {
            throw new RuntimeException('entity not yet persisted');
        }

        return $this->id;
    }

    #[Override]
    public function getUserId(): int
    {
        return $this->user_id;
    }

    #[Override]
    public function getUserName(): string
    {
        return $this->getUser()->getName();
    }

    #[Override]
    public function getSystemsId(): ?int
    {
        return $this->getSystem() !== null ? $this->getSystem()->getId() : null;
    }

    #[Override]
    public function getLayer(): ?LayerInterface
    {
        return $this->getLocation()->getLayer();
    }

    #[Override]
    public function getFlightDirection(): ?DirectionEnum
    {
        return $this->direction;
    }

    #[Override]
    public function setFlightDirection(DirectionEnum $direction): SpacecraftInterface
    {
        $this->direction = $direction;
        return $this;
    }

    #[Override]
    public function getName(): string
    {
        return $this->name;
    }

    #[Override]
    public function setName(string $name): SpacecraftInterface
    {
        $this->name = $name;
        return $this;
    }

    #[Override]
    public function getLssMode(): SpacecraftLssModeEnum
    {
        return $this->lss_mode;
    }

    #[Override]
    public function setLssMode(SpacecraftLssModeEnum $lssMode): SpacecraftInterface
    {
        $this->lss_mode = $lssMode;
        return $this;
    }

    #[Override]
    public function getAlertState(): SpacecraftAlertStateEnum
    {
        return $this->alvl;
    }

    #[Override]
    public function setAlertState(SpacecraftAlertStateEnum $state): SpacecraftInterface
    {
        $this->alvl = $state;
        return $this;
    }

    #[Override]
    public function setAlertStateGreen(): SpacecraftInterface
    {
        return $this->setAlertState(SpacecraftAlertStateEnum::ALERT_GREEN);
    }

    #[Override]
    public function isSystemHealthy(SpacecraftSystemTypeEnum $type): bool
    {
        if (!$this->hasShipSystem($type)) {
            return false;
        }

        return $this->getShipSystem($type)->getStatus() > 0;
    }

    #[Override]
    public function getSystemState(SpacecraftSystemTypeEnum $type): bool
    {
        if (!$this->hasShipSystem($type)) {
            return false;
        }

        return $this->getShipSystem($type)->getMode()->isActivated();
    }

    #[Override]
    public function getImpulseState(): bool
    {
        return $this->getSystemState(SpacecraftSystemTypeEnum::SYSTEM_IMPULSEDRIVE);
    }

    #[Override]
    public function getWarpDriveState(): bool
    {
        return $this->getSystemState(SpacecraftSystemTypeEnum::SYSTEM_WARPDRIVE);
    }

    #[Override]
    public function isWarped(): bool
    {
        return $this->getWarpDriveState();
    }

    #[Override]
    public function getWebState(): bool
    {
        return $this->getHoldingWeb() !== null;
    }

    #[Override]
    public function getCloakState(): bool
    {
        return $this->getSystemState(SpacecraftSystemTypeEnum::SYSTEM_CLOAK);
    }

    #[Override]
    public function getTachyonState(): bool
    {
        return $this->getSystemState(SpacecraftSystemTypeEnum::SYSTEM_TACHYON_SCANNER);
    }

    #[Override]
    public function getSubspaceState(): bool
    {
        return $this->getSystemState(SpacecraftSystemTypeEnum::SYSTEM_SUBSPACE_SCANNER);
    }

    #[Override]
    public function getRPGModuleState(): bool
    {
        return $this->getSystemState(SpacecraftSystemTypeEnum::SYSTEM_RPG_MODULE);
    }

    #[Override]
    public function getHull(): int
    {
        return $this->huelle;
    }

    #[Override]
    public function setHuell(int $hull): SpacecraftInterface
    {
        $this->huelle = $hull;
        return $this;
    }

    #[Override]
    public function getMaxHull(): int
    {
        return $this->max_huelle;
    }

    #[Override]
    public function setMaxHuell(int $maxHull): SpacecraftInterface
    {
        $this->max_huelle = $maxHull;
        return $this;
    }

    #[Override]
    public function getShield(): int
    {
        return $this->schilde;
    }

    #[Override]
    public function setShield(int $schilde): SpacecraftInterface
    {
        $this->schilde = $schilde;
        return $this;
    }

    /**
     * proportional to shield system status
     */
    #[Override]
    public function getMaxShield(bool $isTheoretical = false): int
    {
        if ($isTheoretical || !$this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_SHIELDS)) {
            return $this->max_schilde;
        }

        return (int) (ceil($this->max_schilde
            * $this->getShipSystem(SpacecraftSystemTypeEnum::SYSTEM_SHIELDS)->getStatus() / 100));
    }

    #[Override]
    public function setMaxShield(int $maxShields): SpacecraftInterface
    {
        $this->max_schilde = $maxShields;
        return $this;
    }

    #[Override]
    public function getHealthPercentage(): float
    {
        return ($this->getHull() + $this->getShield())
            / ($this->getMaxHull() + $this->getMaxShield(true)) * 100;
    }

    #[Override]
    public function getShieldState(): bool
    {
        return $this->getSystemState(SpacecraftSystemTypeEnum::SYSTEM_SHIELDS);
    }

    #[Override]
    public function getNbs(): bool
    {
        return $this->getSystemState(SpacecraftSystemTypeEnum::SYSTEM_NBS);
    }

    #[Override]
    public function getLss(): bool
    {
        return $this->getSystemState(SpacecraftSystemTypeEnum::SYSTEM_LSS);
    }

    #[Override]
    public function getPhaserState(): bool
    {
        return $this->getSystemState(SpacecraftSystemTypeEnum::SYSTEM_PHASER);
    }

    #[Override]
    public function isAlertGreen(): bool
    {
        return $this->getAlertState() === SpacecraftAlertStateEnum::ALERT_GREEN;
    }

    #[Override]
    public function getTorpedoState(): bool
    {
        return $this->getSystemState(SpacecraftSystemTypeEnum::SYSTEM_TORPEDO);
    }

    #[Override]
    public function getTorpedoCount(): int
    {
        if ($this->getTorpedoStorage() === null) {
            return 0;
        }

        return $this->getTorpedoStorage()->getStorage()->getAmount();
    }

    #[Override]
    public function isStation(): bool
    {
        return $this instanceof StationInterface;
    }

    #[Override]
    public function isShuttle(): bool
    {
        return $this->getRump()->getCategoryId() === SpacecraftRumpEnum::SHIP_CATEGORY_SHUTTLE;
    }

    #[Override]
    public function isConstruction(): bool
    {
        return $this->getRump()->getCategoryId() === SpacecraftRumpEnum::SHIP_CATEGORY_CONSTRUCTION;
    }

    #[Override]
    public function getDatabaseId(): ?int
    {
        return $this->database_id;
    }

    #[Override]
    public function setDatabaseId(?int $databaseEntryId): SpacecraftInterface
    {
        $this->database_id = $databaseEntryId;
        return $this;
    }

    #[Override]
    public function isDestroyed(): bool
    {
        return $this->is_destroyed;
    }

    #[Override]
    public function setIsDestroyed(bool $isDestroyed): SpacecraftInterface
    {
        $this->is_destroyed = $isDestroyed;
        return $this;
    }

    #[Override]
    public function isDisabled(): bool
    {
        return $this->disabled;
    }

    #[Override]
    public function setDisabled(bool $isDisabled): SpacecraftInterface
    {
        $this->disabled = $isDisabled;
        return $this;
    }



    /**
     * proportional to computer system status
     */
    #[Override]
    public function getHitChance(): int
    {
        if (!$this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_COMPUTER)) {
            return $this->hit_chance;
        }

        return (int) (ceil($this->hit_chance
            * $this->getShipSystem(SpacecraftSystemTypeEnum::SYSTEM_COMPUTER)->getStatus() / 100));
    }

    #[Override]
    public function setHitChance(int $hitChance): SpacecraftInterface
    {
        $this->hit_chance = $hitChance;
        return $this;
    }

    /**
     * proportional to impulsedrive system status
     */
    #[Override]
    public function getEvadeChance(): int
    {
        if (!$this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_IMPULSEDRIVE)) {
            return $this->evade_chance;
        }

        return (int) (ceil($this->evade_chance
            * $this->getShipSystem(SpacecraftSystemTypeEnum::SYSTEM_IMPULSEDRIVE)->getStatus() / 100));
    }

    #[Override]
    public function setEvadeChance(int $evadeChance): SpacecraftInterface
    {
        $this->evade_chance = $evadeChance;
        return $this;
    }

    /**
     * proportional to energy weapon system status
     */
    #[Override]
    public function getBaseDamage(): int
    {
        if (!$this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_PHASER)) {
            return $this->base_damage;
        }

        return (int) (ceil($this->base_damage
            * $this->getShipSystem(SpacecraftSystemTypeEnum::SYSTEM_PHASER)->getStatus() / 100));
    }

    #[Override]
    public function setBaseDamage(int $baseDamage): SpacecraftInterface
    {
        $this->base_damage = $baseDamage;
        return $this;
    }

    /**
     * proportional to sensor system status
     */
    #[Override]
    public function getSensorRange(): int
    {
        if (!$this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_LSS)) {
            return $this->sensor_range;
        }

        return (int) (ceil($this->sensor_range
            * $this->getShipSystem(SpacecraftSystemTypeEnum::SYSTEM_LSS)->getStatus() / 100));
    }

    #[Override]
    public function setSensorRange(int $sensorRange): SpacecraftInterface
    {
        $this->sensor_range = $sensorRange;
        return $this;
    }

    /**
     * proportional to tractor beam system status
     */
    #[Override]
    public function getTractorPayload(): int
    {
        if (!$this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_TRACTOR_BEAM)) {
            return 0;
        }

        return (int) (ceil($this->getRump()->getTractorPayload()
            * $this->getShipSystem(SpacecraftSystemTypeEnum::SYSTEM_TRACTOR_BEAM)->getStatus() / 100));
    }

    #[Override]
    public function getShieldRegenerationTimer(): int
    {
        return $this->shield_regeneration_timer;
    }

    #[Override]
    public function setShieldRegenerationTimer(int $shieldRegenerationTimer): SpacecraftInterface
    {
        $this->shield_regeneration_timer = $shieldRegenerationTimer;
        return $this;
    }

    #[Override]
    public function getState(): SpacecraftStateEnum
    {
        return $this->state;
    }

    #[Override]
    public function setState(SpacecraftStateEnum $state): SpacecraftInterface
    {
        $this->state = $state;
        return $this;
    }

    #[Override]
    public function getIsInEmergency(): bool
    {
        return $this->in_emergency;
    }

    #[Override]
    public function setIsInEmergency(bool $inEmergency): SpacecraftInterface
    {
        $this->in_emergency = $inEmergency;
        return $this;
    }

    #[Override]
    public function isUnderRepair(): bool
    {
        return $this->getState() === SpacecraftStateEnum::SHIP_STATE_REPAIR_ACTIVE
            || $this->getState() === SpacecraftStateEnum::SHIP_STATE_REPAIR_PASSIVE;
    }

    #[Override]
    public function getCrewAssignments(): Collection
    {
        return $this->crew;
    }

    #[Override]
    public function getPosX(): int
    {
        return $this->location->getX();
    }

    #[Override]
    public function getPosY(): int
    {
        return $this->location->getY();
    }

    #[Override]
    public function getCrewCount(): int
    {
        return $this->getCrewAssignments()->count();
    }

    #[Override]
    public function getNeededCrewCount(): int
    {
        $buildplan = $this->getBuildplan();
        if ($buildplan === null) {
            return 0;
        }

        return $buildplan->getCrew();
    }

    #[Override]
    public function getExcessCrewCount(): int
    {
        return $this->getCrewCount() - $this->getNeededCrewCount();
    }

    #[Override]
    public function hasEnoughCrew(?GameControllerInterface $game = null): bool
    {
        $buildplan = $this->getBuildplan();

        if ($buildplan === null) {
            if ($game !== null) {
                $game->addInformation(_("Keine Crew vorhanden"));
            }
            return false;
        }

        $result = $buildplan->getCrew() <= 0
            || $this->getCrewCount() >= $buildplan->getCrew();

        if (!$result && $game !== null) {
            $game->addInformationf(
                _("Es werden %d Crewmitglieder benötigt"),
                $buildplan->getCrew()
            );
        }

        return $result;
    }

    #[Override]
    public function getUser(): UserInterface
    {
        return $this->user;
    }

    #[Override]
    public function setUser(UserInterface $user): SpacecraftInterface
    {
        $this->user = $user;
        return $this;
    }

    #[Override]
    public function getSystem(): ?StarSystemInterface
    {
        return $this->getStarsystemMap() !== null ? $this->getStarsystemMap()->getSystem() : null;
    }

    #[Override]
    public function getModules(): array
    {
        $modules = [];

        $buildplan = $this->getBuildplan();
        if ($buildplan === null) {
            return $modules;
        }

        foreach ($buildplan->getModules() as $obj) {
            $module = $obj->getModule();
            $index = $module->getType() === SpacecraftModuleTypeEnum::SPECIAL ? $module->getId() : $module->getType()->value;
            $modules[$index] = $module;
        }

        return $modules;
    }

    #[Override]
    public function isDeflectorHealthy(): bool
    {
        return $this->isSystemHealthy(SpacecraftSystemTypeEnum::SYSTEM_DEFLECTOR);
    }

    #[Override]
    public function isTroopQuartersHealthy(): bool
    {
        return $this->isSystemHealthy(SpacecraftSystemTypeEnum::SYSTEM_TROOP_QUARTERS);
    }

    #[Override]
    public function isMatrixScannerHealthy(): bool
    {
        return $this->isSystemHealthy(SpacecraftSystemTypeEnum::SYSTEM_MATRIX_SCANNER);
    }

    #[Override]
    public function isTorpedoStorageHealthy(): bool
    {
        return $this->isSystemHealthy(SpacecraftSystemTypeEnum::SYSTEM_TORPEDO_STORAGE);
    }

    #[Override]
    public function isShuttleRampHealthy(): bool
    {
        return $this->isSystemHealthy(SpacecraftSystemTypeEnum::SYSTEM_SHUTTLE_RAMP);
    }

    #[Override]
    public function isWebEmitterHealthy(): bool
    {
        return $this->isSystemHealthy(SpacecraftSystemTypeEnum::SYSTEM_THOLIAN_WEB);
    }

    #[Override]
    public function isWarpAble(): bool
    {
        return $this->isSystemHealthy(SpacecraftSystemTypeEnum::SYSTEM_WARPDRIVE);
    }

    #[Override]
    public function isTractoring(): bool
    {
        return $this->getTractoredShip() !== null;
    }

    #[Override]
    public function isOverColony(): ?ColonyInterface
    {
        return $this->getStarsystemMap() !== null ? $this->getStarsystemMap()->getColony() : null;
    }

    #[Override]
    public function isOverSystem(): ?StarSystemInterface
    {
        $location = $this->getLocation();
        if ($location instanceof StarSystemMapInterface) {
            return null;
        }

        return $location->getSystem();
    }

    #[Override]
    public function isWarpPossible(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_WARPDRIVE) && $this->getSystem() === null;
    }

    #[Override]
    public function getTorpedo(): ?TorpedoTypeInterface
    {
        if ($this->getTorpedoStorage() === null) {
            return null;
        }

        return $this->getTorpedoStorage()->getTorpedo();
    }

    #[Override]
    public function getTorpedoStorage(): ?TorpedoStorageInterface
    {
        return $this->torpedoStorage;
    }

    #[Override]
    public function setTorpedoStorage(?TorpedoStorageInterface $torpedoStorage): SpacecraftInterface
    {
        $this->torpedoStorage = $torpedoStorage;
        return $this;
    }

    #[Override]
    public function getStorage(): Collection
    {
        return $this->storage;
    }

    #[Override]
    public function getLogbook(): Collection
    {
        return $this->logbook;
    }

    #[Override]
    public function getTakeoverActive(): ?ShipTakeoverInterface
    {
        return $this->takeoverActive;
    }

    #[Override]
    public function setTakeoverActive(?ShipTakeoverInterface $takeover): SpacecraftInterface
    {
        $this->takeoverActive = $takeover;

        return $this;
    }

    #[Override]
    public function getTakeoverPassive(): ?ShipTakeoverInterface
    {
        return $this->takeoverPassive;
    }

    #[Override]
    public function setTakeoverPassive(?ShipTakeoverInterface $takeover): SpacecraftInterface
    {
        $this->takeoverPassive = $takeover;

        return $this;
    }

    #[Override]
    public function getStorageSum(): int
    {
        return array_reduce(
            $this->getStorage()->getValues(),
            fn(int $sum, StorageInterface $storage): int => $sum + $storage->getAmount(),
            0
        );
    }

    #[Override]
    public function getMaxStorage(): int
    {
        return $this->getRump()->getStorage();
    }

    #[Override]
    public function getBeamableStorage(): Collection
    {
        return CommodityTransfer::excludeNonBeamable($this->storage);
    }

    #[Override]
    public function getMap(): ?MapInterface
    {
        if ($this->location instanceof MapInterface) {
            return $this->location;

The expression return $this->location returns the type Stu\Orm\Entity\LocationInterface which includes types incompatible with the type-hinted return Stu\Orm\Entity\MapInterface|null.

        }
        if ($this->location instanceof StarSystemMapInterface) {
            return $this->location->getSystem()->getMap();

The method getSystem() does not exist on Stu\Orm\Entity\LocationInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Stu\Orm\Entity\Location. Are you sure you never get one of those?

        }

        return null;
    }

    #[Override]
    public function getMapRegion(): ?MapRegionInterface
    {
        $systemMap = $this->getStarsystemMap();
        if ($systemMap !== null) {
            return null;
        }

        $map = $this->getMap();
        if ($map === null) {
            return null;
        }

        return $map->getMapRegion();
    }

    #[Override]
    public function setLocation(LocationInterface $location): SpacecraftInterface
    {
        $this->location = $location;

        return $this;
    }

    #[Override]
    public function getStarsystemMap(): ?StarSystemMapInterface
    {
        if ($this->location instanceof StarSystemMapInterface) {
            return $this->location;

The expression return $this->location returns the type Stu\Orm\Entity\LocationInterface which includes types incompatible with the type-hinted return Stu\Orm\Entity\StarSystemMapInterface|null.

        }

        return null;
    }

    #[Override]
    public function getLocation(): MapInterface|StarSystemMapInterface
    {
        if (
            $this->location instanceof MapInterface
            || $this->location instanceof StarSystemMapInterface
        ) {
            return $this->location;

The expression return $this->location returns the type Stu\Orm\Entity\LocationInterface which includes types incompatible with the type-hinted return Stu\Orm\Entity\MapInterface|Stu\Orm\Entity\StarSystemMapInterface.

        }

        throw new RuntimeException('unknown type');
    }

    #[Override]
    public function getBeamFactor(): int
    {
        return $this->getRump()->getBeamFactor();
    }

    #[Override]
    public function getSectorString(): string
    {
        return $this->getLocation()->getSectorString();
    }

    #[Override]
    public function getBuildplan(): ?SpacecraftBuildplanInterface
    {
        return $this->buildplan;
    }

    #[Override]
    public function setBuildplan(?SpacecraftBuildplanInterface $spacecraftBuildplan): SpacecraftInterface
    {
        $this->buildplan = $spacecraftBuildplan;
        return $this;
    }

    #[Override]
    public function getSystems(): Collection
    {
        return $this->systems;
    }

    #[Override]
    public function hasShipSystem(SpacecraftSystemTypeEnum $type): bool
    {
        return $this->getSystems()->containsKey($type->value);
    }

    #[Override]
    public function getShipSystem(SpacecraftSystemTypeEnum $type): SpacecraftSystemInterface
    {
        $system = $this->getSystems()->get($type->value);
        if ($system === null) {
            throw new RuntimeException(sprintf('system type %d does not exist on ship', $type->value));
        }

        return $system;
    }

    #[Override]
    public function getHealthySystems(): array
    {
        $healthySystems = [];
        foreach ($this->getSystems() as $system) {
            if ($system->getStatus() > 0) {
                $healthySystems[] = $system;
            }
        }
        return $healthySystems;
    }

    #[Override]
    public function displayNbsActions(): bool
    {
        return !$this->getCloakState()
            && !$this->isWarped();
    }

    #[Override]
    public function isTractorbeamPossible(): bool
    {
        return TractorBeamShipSystem::isTractorBeamPossible($this);
    }

    #[Override]
    public function isBoardingPossible(): bool
    {
        return FightLib::isBoardingPossible($this);
    }

    #[Override]
    public function isInterceptable(): bool
    {
        //TODO can tractored ships be intercepted?!
        return $this->getWarpDriveState();
    }

    #[Override]
    public function getTractoredShip(): ?ShipInterface
    {
        return $this->tractoredShip;
    }

    #[Override]
    public function setTractoredShip(?ShipInterface $ship): SpacecraftInterface
    {
        $this->tractoredShip = $ship;
        return $this;
    }

    #[Override]
    public function setTractoredShipId(?int $shipId): SpacecraftInterface
    {
        $this->tractored_ship_id = $shipId;
        return $this;
    }

    #[Override]
    public function getHoldingWeb(): ?TholianWebInterface
    {
        return $this->holdingWeb;
    }

    #[Override]
    public function setHoldingWeb(?TholianWebInterface $web): SpacecraftInterface
    {
        $this->holdingWeb = $web;

        if ($web === null) {
            $this->holding_web_id = null;
        }

        return $this;
    }

    #[Override]
    public function getHoldingWebBackgroundStyle(): string
    {
        if ($this->getHoldingWeb() === null) {
            return '';
        }

        if ($this->getHoldingWeb()->isFinished()) {
            $icon =  'web.png';
        } else {
            $closeTofinish = $this->getHoldingWeb()->getFinishedTime() - time() < TimeConstants::ONE_HOUR_IN_SECONDS;

            $icon = $closeTofinish ? 'web_u.png' : 'web_u2.png';
        }

        return sprintf('src="assets/buttons/%s"; class="indexedGraphics" style="z-index: 5;"', $icon);
    }

    public function getHoldingWebImageStyle(): string
    {
        if ($this->getHoldingWeb() === null) {
            return '';
        }

        if ($this->getHoldingWeb()->isFinished()) {
            $icon =  'webfill.png';
        } else {
            $closeTofinish = $this->getHoldingWeb()->getFinishedTime() - time() < TimeConstants::ONE_HOUR_IN_SECONDS;

            $icon = $closeTofinish ? 'web_ufill.png' : 'web_ufill2.png';
        }

        return $icon;
    }

    private function getShieldRegenerationPercentage(): int
    {
        return $this->isSystemHealthy(SpacecraftSystemTypeEnum::SYSTEM_SHIELDS) ? 10 : 0;
    }

    #[Override]
    public function getShieldRegenerationRate(): int
    {
        return (int) ceil(($this->getMaxShield() / 100) * $this->getShieldRegenerationPercentage());
    }

    #[Override]
    public function canIntercept(): bool
    {
        return $this->isSystemHealthy(SpacecraftSystemTypeEnum::SYSTEM_WARPDRIVE)
            && !$this->isTractoring()
            && (!$this instanceof ShipInterface || !$this->isTractored());
    }

    #[Override]
    public function canMove(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_WARPDRIVE)
            || $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_IMPULSEDRIVE);
    }

    #[Override]
    public function hasActiveWeapon(): bool
    {
        return $this->getPhaserState() || $this->getTorpedoState();
    }

    #[Override]
    public function hasEscapePods(): bool
    {
        return $this->getRump()->isEscapePods() && $this->getCrewCount() > 0;
    }

    #[Override]
    public function getRepairRate(): int
    {
        // @todo
        return 100;
    }

    #[Override]
    public function getRump(): SpacecraftRumpInterface
    {
        return $this->rump;
    }

    #[Override]
    public function getRumpId(): int
    {
        return $this->getRump()->getId();
    }

    #[Override]
    public function getRumpName(): string
    {
        return $this->getRump()->getName();
    }

    #[Override]
    public function setRump(SpacecraftRumpInterface $shipRump): SpacecraftInterface
    {
        $this->rump = $shipRump;
        return $this;
    }

    #[Override]
    public function hasPhaser(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_PHASER);
    }

    #[Override]
    public function hasTorpedo(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_TORPEDO);
    }

    #[Override]
    public function hasCloak(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_CLOAK);
    }

    #[Override]
    public function hasTachyonScanner(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_TACHYON_SCANNER);
    }

    #[Override]
    public function hasShuttleRamp(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_SHUTTLE_RAMP);
    }

    #[Override]
    public function hasSubspaceScanner(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_SUBSPACE_SCANNER);
    }

    #[Override]
    public function hasAstroLaboratory(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_ASTRO_LABORATORY);
    }

    #[Override]
    public function hasWarpdrive(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_WARPDRIVE);
    }

    #[Override]
    public function hasReactor(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_WARPCORE) ||
            $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_FUSION_REACTOR) ||
            $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_SINGULARITY_REACTOR);
    }

    #[Override]
    public function hasRPGModule(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_RPG_MODULE);
    }

    #[Override]
    public function hasNbsLss(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_LSS);
    }

    #[Override]
    public function hasUplink(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_UPLINK);
    }

    #[Override]
    public function hasTranswarp(): bool
    {
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_TRANSWARP_COIL);
    }

    #[Override]
    public function getTranswarpCooldown(): ?int
    {
        $cooldown = $this->getShipSystem(SpacecraftSystemTypeEnum::SYSTEM_TRANSWARP_COIL)->getCooldown();

        return $cooldown > time() ? $cooldown : null;
    }

    #[Override]
    public function getMaxTorpedos(): int
    {
        return $this->getRump()->getBaseTorpedoStorage()
            + ($this->isSystemHealthy(SpacecraftSystemTypeEnum::SYSTEM_TORPEDO_STORAGE)
                ? TorpedoStorageShipSystem::TORPEDO_CAPACITY : 0);
    }

    #[Override]
    public function hasFreeShuttleSpace(?LoggerUtilInterface $loggerUtil = null): bool
    {
        if ($loggerUtil !== null) {
            $loggerUtil->log(sprintf('rumpShuttleSlots: %d', $this->getRump()->getShuttleSlots()));
            $loggerUtil->log(sprintf('storedShuttleCount: %d', $this->getStoredShuttleCount()));
        }
        return $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_SHUTTLE_RAMP)
            && $this->getRump()->getShuttleSlots() - $this->getStoredShuttleCount() > 0;
    }

    #[Override]
    public function getStoredShuttles(): array
    {
        $shuttles = [];

        foreach ($this->getStorage() as $stor) {
            if ($stor->getCommodity()->isShuttle()) {
                $shuttles[] = $stor->getCommodity();
            }
        }

        return $shuttles;
    }

    #[Override]
    public function getStoredShuttleCount(): int
    {
        $count = 0;

        foreach ($this->getStorage() as $stor) {
            if ($stor->getCommodity()->isShuttle()) {
                $count += $stor->getAmount();
            }
        }

        return $count;
    }

    /**
     * @return CommodityInterface[]
     */
    #[Override]
    public function getStoredBuoy(): array
    {
        $buoy = [];

        foreach ($this->getStorage() as $stor) {
            if ($stor->getCommodity()->isBouy()) {
                $buoy[] = $stor->getCommodity();
            }
        }

        return $buoy;
    }


    #[Override]
    public function hasStoredBuoy(): bool
    {
        return $this->getStoredBuoy() !== [];
    }

    #[Override]
    public function canMan(): bool
    {
        $buildplan = $this->getBuildplan();

        return $buildplan !== null
            && $buildplan->getCrew() > 0
            && $this->hasShipSystem(SpacecraftSystemTypeEnum::SYSTEM_LIFE_SUPPORT);
    }

    #[Override]
    public function hasCrewmanOfUser(int $userId): bool
    {
        foreach ($this->getCrewAssignments() as $shipCrew) {
            if ($shipCrew->getCrew()->getUser()->getId() === $userId) {
                return true;
            }
        }

        return false;
    }

    #[Override]
    public function getHref(): string
    {
        return sprintf(
            '%s?%s=1&id=%d',
            $this->getType()->getModuleView()->getPhpPage(),
            $this->getType()->getViewIdentifier(),
            $this->getId()
        );
    }

    #[Override]
    public function __toString(): string
    {
        if ($this->id !== null) {
            return sprintf('id: %d, name: %s', $this->getId(), $this->getName());
        }

        return $this->getName();
    }

    #[Override]
    public function getHullColorStyle(): string
    {
        return $this->getColorStyle($this->getHull(), $this->getMaxHull());
    }

    private function getColorStyle(int $actual, int $max): string
    {
        // full
        if ($actual === $max) {
            return '';
        }

        // less than 100% - green
        if ($actual / $max > 0.75) {
            return 'color: #19c100;';
        }

        // less than 75% - yellow
        if ($actual / $max > 0.50) {
            return 'color: #f4e932;';
        }

        // less than 50% - orange
        if ($actual / $max > 0.25) {
            return 'color: #f48b28;';
        }

        // less than 25% - red
        return 'color: #ff3c3c;';
    }
}