Stu\Orm\Entity\Location

Complexity

Total Complexity

22

Size/Duplication

Total Lines	205
Duplicated Lines	0 %

Test Coverage

Coverage

44.9%

Importance

Changes	1
Bugs	0	Features	1

19 Methods

Rating	Name	Duplication	Size	Complexity
A	getCx()	0	4	1
A	getTrumfields()	0	4	1
A	getCy()	0	4	1
A	getId()	0	4	1
A	__construct()	0	7	1
A	getSpacecrafts()	0	4	1
A	getFieldType()	0	4	1
A	setFieldType()	0	6	1
A	getFieldId()	0	4	1
A	getBuoys()	0	4	1
A	isOverWormhole()	0	4	2
A	addAnomaly()	0	3	1
A	getAnomaly()	0	4	1
A	isMap()	0	4	1
A	getLocationMinings()	0	4	1
A	getSignatures()	0	4	1
A	getRandomWormholeEntry()	0	13	3
A	hasAnomaly()	0	4	1
A	getAnomalies()	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\Index;
use Doctrine\ORM\Mapping\InheritanceType;
use Doctrine\ORM\Mapping\JoinColumn;
use Doctrine\ORM\Mapping\ManyToOne;
use Doctrine\ORM\Mapping\OneToMany;
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 Stu\Component\Anomaly\Type\AnomalyTypeEnum;
use Stu\Orm\Repository\LocationRepository;

#[Table(name: 'stu_location')]
#[Index(name: 'location_coords_idx', columns: ['layer_id', 'cx', 'cy'])]
#[Index(name: 'location_coords_reverse_idx', columns: ['layer_id', 'cy', 'cx'])]
#[Index(name: 'location_field_type_idx', columns: ['field_id'])]
#[Entity(repositoryClass: LocationRepository::class)]
#[InheritanceType('JOINED')]
#[DiscriminatorColumn(name: 'discr', type: 'string')]
#[DiscriminatorMap([
    'map' => Map::class,
    'systemMap' => StarSystemMap::class
])]
abstract class Location implements LocationInterface
{
    #[Id]
    #[Column(type: 'integer')]
    #[GeneratedValue(strategy: 'IDENTITY')]
    private int $id;

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

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

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

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

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

    #[ManyToOne(targetEntity: 'Layer')]
    #[JoinColumn(name: 'layer_id', referencedColumnName: 'id')]
    protected ?LayerInterface $layer;

    #[ManyToOne(targetEntity: 'MapFieldType')]
    #[JoinColumn(name: 'field_id', referencedColumnName: 'id')]
    private MapFieldTypeInterface $mapFieldType;

    /**
     * @var ArrayCollection<int, SpacecraftInterface>
     */
    #[OneToMany(targetEntity: 'Spacecraft', mappedBy: 'location', indexBy: 'id', fetch: 'EXTRA_LAZY')]
    private Collection $spacecrafts;

    /**
     * @var ArrayCollection<int, TrumfieldInterface>
     */
    #[OneToMany(targetEntity: 'Trumfield', mappedBy: 'location', indexBy: 'id', fetch: 'EXTRA_LAZY')]
    private Collection $trumfields;

    /**
     * @var ArrayCollection<int, FlightSignatureInterface>
     */
    #[OneToMany(targetEntity: 'FlightSignature', mappedBy: 'location')]
    #[OrderBy(['time' => 'DESC'])]
    private Collection $signatures;

    /**
     * @var ArrayCollection<int, BuoyInterface>
     */
    #[OneToMany(targetEntity: 'Buoy', mappedBy: 'location', indexBy: 'id', fetch: 'EXTRA_LAZY')]
    private Collection $buoys;

    /**
     * @var ArrayCollection<int, AnomalyInterface>
     */
    #[OneToMany(targetEntity: 'Anomaly', mappedBy: 'location', indexBy: 'anomaly_type_id', fetch: 'EXTRA_LAZY')]
    private Collection $anomalies;

    /**
     * @var ArrayCollection<int, LocationMiningInterface>
     */
    #[OneToMany(targetEntity: 'LocationMining', mappedBy: 'location')]
    private Collection $locationMinings;

    public function __construct()
    {
        $this->spacecrafts = new ArrayCollection();
        $this->trumfields = new ArrayCollection();
        $this->signatures = new ArrayCollection();
        $this->buoys = new ArrayCollection();
        $this->anomalies = new ArrayCollection();
    }

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

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

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

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

    #[Override]
    public function getFieldType(): MapFieldTypeInterface
    {
        return $this->mapFieldType;
    }

    #[Override]
    public function setFieldType(MapFieldTypeInterface $mapFieldType): LocationInterface
    {
        $this->mapFieldType = $mapFieldType;

        return $this;
    }

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

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

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

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

    public function addAnomaly(AnomalyInterface $anomaly): void
    {
        $this->anomalies->set($anomaly->getAnomalyType()->getId(), $anomaly);
    }

    #[Override]
    public function hasAnomaly(AnomalyTypeEnum $type): bool
    {
        return $this->anomalies->containsKey($type->value);
    }

    #[Override]
    public function getAnomaly(AnomalyTypeEnum $type): ?AnomalyInterface
    {
        return $this->anomalies->get($type->value);
    }

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

    /**
     * @return Collection<int, WormholeEntryInterface>
     */
    protected abstract function getWormholeEntries(): Collection;

    #[Override]
    public function getRandomWormholeEntry(): ?WormholeEntryInterface
    {
        $wormholeEntries = $this->getWormholeEntries();
        if ($wormholeEntries->isEmpty()) {
            return null;
        }

        $usableEntries = $wormholeEntries
            ->filter(fn(WormholeEntryInterface $entry): bool => $entry->isUsable($this))
            ->toArray();

        return $usableEntries === [] ? null : $usableEntries[array_rand($usableEntries)];
    }

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

    #[Override]
    public function isOverWormhole(): bool
    {
        return $this->isMap() && $this->getRandomWormholeEntry() !== null;
    }

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