Colony::getColonyClass() - Code Metrics - Inspection of "remove obsolete attributes" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( dfb12b...5aafb2 )

by Janko

created 2024-08-16 06:54 UTC

Colony::getColonyClass() A

↳ Parent: Colony

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?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\Entity;
use Doctrine\ORM\Mapping\GeneratedValue;
use Doctrine\ORM\Mapping\Id;
use Doctrine\ORM\Mapping\Index;
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;
filter:
    dependency_paths: ["lib/*"]
use Stu\Component\Colony\ColonyMenuEnum;
use Stu\Component\Game\TimeConstants;
filter:
    dependency_paths: ["lib/*"]
use Stu\Lib\Colony\PlanetFieldHostTypeEnum;
use Stu\Module\Colony\View\ShowColony\ShowColony;
use Stu\Module\PlayerSetting\Lib\UserEnum;
filter:
    dependency_paths: ["lib/*"]
use Stu\Orm\Repository\ColonyRepository;

#[Table(name: 'stu_colonies')]
#[Index(name: 'colony_user_idx', columns: ['user_id'])]
#[Index(name: 'colony_classes_idx', columns: ['colonies_classes_id'])]
#[Index(name: 'colony_sys_map_idx', columns: ['starsystem_map_id'])]
#[Entity(repositoryClass: ColonyRepository::class)]
class Colony implements ColonyInterface
{
    #[Id]
    #[Column(type: 'integer')]
    #[GeneratedValue(strategy: 'IDENTITY')]
    private int $id;

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

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

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


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

    #[Column(type: 'string', length: 100)]
    private string $planet_name = '';

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

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

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

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

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

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

    #[Column(type: 'text', nullable: true)]
    private ?string $mask = null;

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

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

    #[Column(type: 'boolean')]
    private bool $immigrationstate = true;

    #[Column(type: 'integer', length: 6, nullable: true)]
    private ?int $shields = 0;

    #[Column(type: 'integer', length: 6, nullable: true)]
    private ?int $shield_frequency = 0;

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


    #[Column(type: 'integer', length: 3)]
    private int $rotation_factor = 1;

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

    #[ManyToOne(targetEntity: 'ColonyClass')]
    #[JoinColumn(name: 'colonies_classes_id', referencedColumnName: 'id')]
    private ColonyClassInterface $colonyClass;

    #[OneToOne(targetEntity: 'StarSystemMap', inversedBy: 'colony')]
    #[JoinColumn(name: 'starsystem_map_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
    private StarSystemMapInterface $starsystem_map;

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

    /**
     * @var ArrayCollection<int, PlanetFieldInterface>
     */
    #[OneToMany(targetEntity: 'PlanetField', mappedBy: 'colony', indexBy: 'field_id', fetch: 'EXTRA_LAZY')]
    #[OrderBy(['field_id' => 'ASC'])]
    private Collection $planetFields;

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

    #[ManyToOne(targetEntity: 'TorpedoType')]
    #[JoinColumn(name: 'torpedo_type', referencedColumnName: 'id')]
    private ?TorpedoTypeInterface $torpedo = null;

    /**
     * @var DatabaseEntryInterface|null
     */
    #[OneToOne(targetEntity: 'DatabaseEntry')]
    #[JoinColumn(name: 'database_id', referencedColumnName: 'id')]
    private ?DatabaseEntryInterface $databaseEntry;

    /**
     * @var ArrayCollection<int, FleetInterface>
     */
    #[OneToMany(targetEntity: 'Fleet', mappedBy: 'defendedColony')]
    private Collection $defenders;

    /**
     * @var ArrayCollection<int, FleetInterface>
     */
    #[OneToMany(targetEntity: 'Fleet', mappedBy: 'blockedColony')]
    private Collection $blockers;

    /**
     * @var ArrayCollection<int, ShipCrewInterface>
     */
    #[OneToMany(targetEntity: 'ShipCrew', mappedBy: 'colony')]
    private Collection $crewAssignments;

    /**
     * @var ArrayCollection<int, ShipCrewInterface>
     */
    #[OneToMany(targetEntity: 'CrewTraining', mappedBy: 'colony')]
    private Collection $crewTrainings;

    /**
     * @var Collection<int, ColonyDepositMiningInterface>
     */
    #[OneToMany(targetEntity: 'ColonyDepositMining', mappedBy: 'colony')]
    #[OrderBy(['commodity_id' => 'ASC'])]
    private Collection $depositMinings;

    public function __construct()
    {
        $this->planetFields = new ArrayCollection();
        $this->storage = new ArrayCollection();
        $this->defenders = new ArrayCollection();
        $this->blockers = new ArrayCollection();
        $this->crewAssignments = new ArrayCollection();
        $this->crewTrainings = new ArrayCollection();
        $this->depositMinings = new ArrayCollection();
    }

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

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

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

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

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

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

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

    #[Override]
    public function getNameAndSectorString(): string
    {
        return sprintf(
            '%s %s',
            $this->getName(),
            $this->getSectorString()
        );
    }

    #[Override]
    public function getSystemString(): string
    {
        return sprintf('%s-System (%s|%s)', $this->getSystem()->getName(), $this->getSystem()->getCx(), $this->getSystem()->getCy());
    }

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

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

    #[Override]
    public function setPlanetName(string $planet_name): ColonyInterface
    {
        $this->planet_name = $planet_name;
        return $this;
    }

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

    #[Override]
    public function setWorkers(int $bev_work): ColonyInterface
    {
        $this->bev_work = $bev_work;
        return $this;
    }

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

    #[Override]
    public function setWorkless(int $bev_free): ColonyInterface
    {
        $this->bev_free = $bev_free;
        return $this;
    }

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

    #[Override]
    public function setMaxBev(int $bev_max): ColonyInterface
    {
        $this->bev_max = $bev_max;
        return $this;
    }

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

    #[Override]
    public function setEps(int $eps): ColonyInterface
    {
        $this->eps = $eps;
        return $this;
    }

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

    #[Override]
    public function setMaxEps(int $max_eps): ColonyInterface
    {
        $this->max_eps = $max_eps;
        return $this;
    }

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

    #[Override]
    public function setMaxStorage(int $max_storage): ColonyInterface
    {
        $this->max_storage = $max_storage;
        return $this;
    }

    #[Override]
    public function getMask(): ?string
    {
        return $this->mask;
    }

    #[Override]
    public function setMask(?string $mask): ColonyInterface
    {
        $this->mask = $mask;
        return $this;
    }

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

    #[Override]
    public function setDatabaseEntry(?DatabaseEntryInterface $entry): ColonyInterface
    {
        $this->databaseEntry = $entry;
        return $this;
    }

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

    #[Override]
    public function setPopulationlimit(int $populationlimit): ColonyInterface
    {
        $this->populationlimit = $populationlimit;
        return $this;
    }

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

    #[Override]
    public function setImmigrationstate(bool $immigrationstate): ColonyInterface
    {
        $this->immigrationstate = $immigrationstate;
        return $this;
    }

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

    #[Override]
    public function setShields(?int $shields): ColonyInterface
    {
        $this->shields = $shields;
        return $this;
    }

    #[Override]
    public function getTwilightZone(): int
    {
        $twilightZone = 0;

        $width = $this->getSurfaceWidth();
        $rotationTime = $this->getRotationTime();
        $colonyTimeSeconds = $this->getColonyTimeSeconds();

        if ($this->getDayTimePrefix() == 1) {
            $scaled = floor((((100 / ($rotationTime * 0.125)) * ($colonyTimeSeconds - $rotationTime * 0.25)) / 100) * $width);
            if ($scaled == 0) {
                $twilightZone = - (($width) - 1);
            } elseif ((int) - (($width) - ceil($scaled)) == 0) {
                $twilightZone = -1;
            } else {
                $twilightZone = (int) - (($width) - $scaled);
            }
        }
        if ($this->getDayTimePrefix() == 2) {
            $twilightZone = $width;
        }
        if ($this->getDayTimePrefix() == 3) {
            $scaled = floor((((100 / ($rotationTime * 0.125)) * ($colonyTimeSeconds - $rotationTime * 0.75)) / 100) * $width);
            $twilightZone = (int) ($width - $scaled);
        }
        if ($this->getDayTimePrefix() == 4) {
            $twilightZone = 0;
        }

        return $twilightZone;
    }

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

    #[Override]
    public function setShieldFrequency(?int $shieldFrequency): ColonyInterface
    {
        $this->shield_frequency = $shieldFrequency;
        return $this;
    }

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

    #[Override]
    public function setTorpedo(?TorpedoTypeInterface $torpedoType): ColonyInterface
    {
        $this->torpedo = $torpedoType;
        return $this;
    }

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

    #[Override]
    public function setRotationFactor(int $rotationFactor): ColonyInterface
    {
        $this->rotation_factor = $rotationFactor;

        return $this;
    }

    #[Override]
    public function getRotationTime(): int
    {
        return (int) (TimeConstants::ONE_DAY_IN_SECONDS * $this->getRotationFactor() / 100);
    }

    #[Override]
    public function getColonyTimeSeconds(): int
    {
        return time() % $this->getRotationTime();
    }

    #[Override]
    public function getColonyTimeHour(): ?string
    {
        $rotationTime = $this->getRotationTime();

        return sprintf("%02d", (int) floor(($rotationTime / 3600) * ($this->getColonyTimeSeconds() / $rotationTime)));
    }

    #[Override]
    public function getColonyTimeMinute(): ?string
    {
        $rotationTime = $this->getRotationTime();

        return sprintf("%02d", (int) floor(60 * (($rotationTime / 3600) * ($this->getColonyTimeSeconds() / $rotationTime) - ((int) $this->getColonyTimeHour()))));
    }

    #[Override]
    public function getDayTimePrefix(): ?int
    {
        $daytimeprefix = null;
        $daypercent = (int) (($this->getColonyTimeSeconds() / $this->getRotationTime()) * 100);
        if ($daypercent > 25 && $daypercent <= 37.5) {
            $daytimeprefix = 1; //Sonnenaufgang
        }
        if ($daypercent > 37.5 && $daypercent <= 75) {
            $daytimeprefix = 2; //Tag
        }
        if ($daypercent > 75 && $daypercent <= 87.5) {
            $daytimeprefix = 3; //Sonnenuntergang
        }
        if ($daypercent > 87.5 || $daypercent <= 25) {
            $daytimeprefix = 4; //Nacht
        }
        return $daytimeprefix;
    }

    #[Override]
    public function getDayTimeName(): ?string
    {
        $daytimename = null;
        if ($this->getDayTimePrefix() == 1) {
            $daytimename = 'Morgen';
        }

        if ($this->getDayTimePrefix() == 2) {
            $daytimename = 'Tag';
        }

        if ($this->getDayTimePrefix() == 3) {
            $daytimename = 'Abend';
        }

        if ($this->getDayTimePrefix() == 4) {
            $daytimename = 'Nacht';
        }
        return $daytimename;
    }

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

    #[Override]
    public function setSurfaceWidth(int $surfaceWidth): ColonyInterface
    {
        $this->surface_width = $surfaceWidth;
        return $this;
    }

    #[Override]
    public function getColonyClass(): ColonyClassInterface
    {
        return $this->colonyClass;
    }

    #[Override]
    public function setColonyClass(ColonyClassInterface $colonyClass): ColonyInterface
    {
        $this->colonyClass = $colonyClass;
        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 storagePlaceLeft(): bool
    {
        return $this->getMaxStorage() > $this->getStorageSum();
    }

    #[Override]
    public function getStarsystemMap(): StarSystemMapInterface
    {
        return $this->starsystem_map;
    }

    #[Override]
    public function setStarsystemMap(StarSystemMapInterface $systemMap): ColonyInterface
    {
        $this->starsystem_map = $systemMap;

        return $this;
    }

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

    #[Override]
    public function getBeamFactor(): int
    {
        return 10;
    }

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

    /**
     * @return StorageInterface[]
     */
    #[Override]
    public function getBeamableStorage(): array
    {
        return array_filter(
            $this->getStorage()->getValues(),
            fn(StorageInterface $storage): bool => $storage->getCommodity()->isBeamable() === true
        );
    }

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

    #[Override]
    public function isDefended(): bool
    {
        return !$this->getDefenders()->isEmpty();
    }

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

    #[Override]
    public function isBlocked(): bool
    {
        return !$this->getBlockers()->isEmpty();
    }

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

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

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

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

    #[Override]
    public function getUserDepositMinings(): array
    {
        $result = [];

        foreach ($this->depositMinings as $deposit) {
            if ($deposit->getUser() === $this->getUser()) {
                $result[$deposit->getCommodity()->getId()] = $deposit;
            }
        }

        return $result;
    }

    #[Override]
    public function isFree(): bool
    {
        return $this->getUserId() === UserEnum::USER_NOONE;
    }

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

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

    #[Override]
    public function getPopulation(): int
    {
        return $this->getWorkers() + $this->getWorkless();
    }

    #[Override]
    public function getFreeHousing(): int
    {
        return $this->getMaxBev() - $this->getPopulation();
    }

    #[Override]
    public function lowerEps(int $value): void
    {
        $this->setEps($this->getEps() - $value);
    }

    #[Override]
    public function upperEps(int $value): void
    {
        $this->setEps($this->getEps() + $value);
    }

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

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

    #[Override]
    public function getPlanetFieldHostIdentifier(): string
    {
        return 'colony';
    }

    #[Override]
    public function getPlanetFieldHostColumnIdentifier(): string
    {
        return 'colonies_id';
    }

    #[Override]
    public function isColony(): bool
    {
        return true;
    }

    #[Override]
    public function getHostType(): PlanetFieldHostTypeEnum
    {
        return PlanetFieldHostTypeEnum::COLONY;
    }

    #[Override]
    public function getDefaultViewIdentifier(): string
    {
        return ShowColony::VIEW_IDENTIFIER;
    }

    #[Override]
    public function isMenuAllowed(ColonyMenuEnum $menu): bool
    {
        return true;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Stu\Orm\Entity;
6
7			use Doctrine\Common\Collections\ArrayCollection;
8			use Doctrine\Common\Collections\Collection;
9			use Doctrine\ORM\Mapping\Column;
10			use Doctrine\ORM\Mapping\Entity;
11			use Doctrine\ORM\Mapping\GeneratedValue;
12			use Doctrine\ORM\Mapping\Id;
13			use Doctrine\ORM\Mapping\Index;
14			use Doctrine\ORM\Mapping\JoinColumn;
15			use Doctrine\ORM\Mapping\ManyToOne;
16			use Doctrine\ORM\Mapping\OneToMany;
17			use Doctrine\ORM\Mapping\OneToOne;
18			use Doctrine\ORM\Mapping\OrderBy;
19			use Doctrine\ORM\Mapping\Table;
20			use Override;
			0 ignored issues – show Bug introduced 2024-07-04 06:34 UTC by Report Bug Copy Issue Report The type `Override` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
21			use Stu\Component\Colony\ColonyMenuEnum;
22			use Stu\Component\Game\TimeConstants;
			0 ignored issues – show Bug introduced 2023-07-18 10:33 UTC by Report Bug Copy Issue Report The type `Stu\Component\Game\TimeConstants` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
23			use Stu\Lib\Colony\PlanetFieldHostTypeEnum;
24			use Stu\Module\Colony\View\ShowColony\ShowColony;
25			use Stu\Module\PlayerSetting\Lib\UserEnum;
			0 ignored issues – show Bug introduced 2024-07-04 06:34 UTC by Report Bug Copy Issue Report The type `Stu\Module\PlayerSetting\Lib\UserEnum` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
26			use Stu\Orm\Repository\ColonyRepository;
27
28			#[Table(name: 'stu_colonies')]
29			#[Index(name: 'colony_user_idx', columns: ['user_id'])]
30			#[Index(name: 'colony_classes_idx', columns: ['colonies_classes_id'])]
31			#[Index(name: 'colony_sys_map_idx', columns: ['starsystem_map_id'])]
32			#[Entity(repositoryClass: ColonyRepository::class)]
33			class Colony implements ColonyInterface
34			{
35			#[Id]
36			#[Column(type: 'integer')]
37			#[GeneratedValue(strategy: 'IDENTITY')]
38			private int $id;
39
40			#[Column(type: 'integer')]
41			private int $colonies_classes_id = 0;
42
43			#[Column(type: 'integer')]
44			private int $user_id = 0;
45
46			#[Column(type: 'integer')]
47			private int $starsystem_map_id = 0;
			0 ignored issues – show introduced 2024-03-23 13:09 UTC by Report Bug Copy Issue Report The private property `$starsystem_map_id` is not used, and could be removed. Loading history...
48
49			#[Column(type: 'string')]
50			private string $name = '';
51
52			#[Column(type: 'string', length: 100)]
53			private string $planet_name = '';
54
55			#[Column(type: 'integer', length: 5)]
56			private int $bev_work = 0;
57
58			#[Column(type: 'integer', length: 5)]
59			private int $bev_free = 0;
60
61			#[Column(type: 'integer', length: 5)]
62			private int $bev_max = 0;
63
64			#[Column(type: 'integer', length: 5)]
65			private int $eps = 0;
66
67			#[Column(type: 'integer', length: 5)]
68			private int $max_eps = 0;
69
70			#[Column(type: 'integer', length: 5)]
71			private int $max_storage = 0;
72
73			#[Column(type: 'text', nullable: true)]
74			private ?string $mask = null;
75
76			#[Column(type: 'integer', nullable: true)]
77			private ?int $database_id = null;
78
79			#[Column(type: 'integer', length: 5)]
80			private int $populationlimit = 0;
81
82			#[Column(type: 'boolean')]
83			private bool $immigrationstate = true;
84
85			#[Column(type: 'integer', length: 6, nullable: true)]
86			private ?int $shields = 0;
87
88			#[Column(type: 'integer', length: 6, nullable: true)]
89			private ?int $shield_frequency = 0;
90
91			#[Column(type: 'integer', length: 3, nullable: true)]
92			private ?int $torpedo_type = null;
			0 ignored issues – show introduced 2023-02-26 17:01 UTC by Report Bug Copy Issue Report The private property `$torpedo_type` is not used, and could be removed. Loading history...
93
94			#[Column(type: 'integer', length: 3)]
95			private int $rotation_factor = 1;
96
97			#[Column(type: 'integer', length: 2)]
98			private int $surface_width = 0;
99
100			#[ManyToOne(targetEntity: 'ColonyClass')]
101			#[JoinColumn(name: 'colonies_classes_id', referencedColumnName: 'id')]
102			private ColonyClassInterface $colonyClass;
103
104			#[OneToOne(targetEntity: 'StarSystemMap', inversedBy: 'colony')]
105			#[JoinColumn(name: 'starsystem_map_id', referencedColumnName: 'id', onDelete: 'CASCADE')]
106			private StarSystemMapInterface $starsystem_map;
107
108			#[ManyToOne(targetEntity: 'User')]
109			#[JoinColumn(name: 'user_id', referencedColumnName: 'id')]
110			private UserInterface $user;
111
112			/**
113			* @var ArrayCollection<int, PlanetFieldInterface>
114			*/
115			#[OneToMany(targetEntity: 'PlanetField', mappedBy: 'colony', indexBy: 'field_id', fetch: 'EXTRA_LAZY')]
116			#[OrderBy(['field_id' => 'ASC'])]
117			private Collection $planetFields;
118
119			/**
120			* @var ArrayCollection<int, StorageInterface>
121			*/
122			#[OneToMany(targetEntity: 'Storage', mappedBy: 'colony', indexBy: 'commodity_id')]
123			#[OrderBy(['commodity_id' => 'ASC'])]
124			private Collection $storage;
125
126			#[ManyToOne(targetEntity: 'TorpedoType')]
127			#[JoinColumn(name: 'torpedo_type', referencedColumnName: 'id')]
128			private ?TorpedoTypeInterface $torpedo = null;
129
130			/**
131			* @var DatabaseEntryInterface\|null
132			*/
133			#[OneToOne(targetEntity: 'DatabaseEntry')]
134			#[JoinColumn(name: 'database_id', referencedColumnName: 'id')]
135			private ?DatabaseEntryInterface $databaseEntry;
136
137			/**
138			* @var ArrayCollection<int, FleetInterface>
139			*/
140			#[OneToMany(targetEntity: 'Fleet', mappedBy: 'defendedColony')]
141			private Collection $defenders;
142
143			/**
144			* @var ArrayCollection<int, FleetInterface>
145			*/
146			#[OneToMany(targetEntity: 'Fleet', mappedBy: 'blockedColony')]
147			private Collection $blockers;
148
149			/**
150			* @var ArrayCollection<int, ShipCrewInterface>
151			*/
152			#[OneToMany(targetEntity: 'ShipCrew', mappedBy: 'colony')]
153			private Collection $crewAssignments;
154
155			/**
156			* @var ArrayCollection<int, ShipCrewInterface>
157			*/
158			#[OneToMany(targetEntity: 'CrewTraining', mappedBy: 'colony')]
159			private Collection $crewTrainings;
160
161			/**
162			* @var Collection<int, ColonyDepositMiningInterface>
163			*/
164			#[OneToMany(targetEntity: 'ColonyDepositMining', mappedBy: 'colony')]
165			#[OrderBy(['commodity_id' => 'ASC'])]
166			private Collection $depositMinings;
167
168			public function __construct()
169			{
170			$this->planetFields = new ArrayCollection();
171			$this->storage = new ArrayCollection();
172			$this->defenders = new ArrayCollection();
173			$this->blockers = new ArrayCollection();
174			$this->crewAssignments = new ArrayCollection();
175			$this->crewTrainings = new ArrayCollection();
176			$this->depositMinings = new ArrayCollection();
177			}
178
179			#[Override]
180			public function getId(): int
181			{
182			return $this->id;
183			}
184
185			#[Override]
186			public function getColonyClassId(): int
187			{
188			return $this->colonies_classes_id;
189			}
190
191			#[Override]
192			public function getUserId(): int
193			{
194			return $this->user_id;
195			}
196
197			#[Override]
198			public function getSx(): int
199			{
200			return $this->getStarsystemMap()->getSx();
201			}
202
203			#[Override]
204			public function getSy(): int
205			{
206			return $this->getStarsystemMap()->getSy();
207			}
208
209			#[Override]
210			public function getSystemsId(): int
211			{
212			return $this->getSystem()->getId();
213			}
214
215			#[Override]
216			public function getName(): string
217			{
218			return $this->name;
219			}
220
221			#[Override]
222			public function getNameAndSectorString(): string
223			{
224			return sprintf(
225			'%s %s',
226			$this->getName(),
227			$this->getSectorString()
228			);
229			}
230
231			#[Override]
232			public function getSystemString(): string
233			{
234			return sprintf('%s-System (%s\|%s)', $this->getSystem()->getName(), $this->getSystem()->getCx(), $this->getSystem()->getCy());
235			}
236
237			#[Override]
238			public function setName(string $name): ColonyInterface
239			{
240			$this->name = $name;
241			return $this;
242			}
243
244			#[Override]
245			public function getPlanetName(): string
246			{
247			return $this->planet_name;
248			}
249
250			#[Override]
251			public function setPlanetName(string $planet_name): ColonyInterface
252			{
253			$this->planet_name = $planet_name;
254			return $this;
255			}
256
257			#[Override]
258			public function getWorkers(): int
259			{
260			return $this->bev_work;
261			}
262
263			#[Override]
264			public function setWorkers(int $bev_work): ColonyInterface
265			{
266			$this->bev_work = $bev_work;
267			return $this;
268			}
269
270			#[Override]
271			public function getWorkless(): int
272			{
273			return $this->bev_free;
274			}
275
276			#[Override]
277			public function setWorkless(int $bev_free): ColonyInterface
278			{
279			$this->bev_free = $bev_free;
280			return $this;
281			}
282
283			#[Override]
284			public function getMaxBev(): int
285			{
286			return $this->bev_max;
287			}
288
289			#[Override]
290			public function setMaxBev(int $bev_max): ColonyInterface
291			{
292			$this->bev_max = $bev_max;
293			return $this;
294			}
295
296			#[Override]
297			public function getEps(): int
298			{
299			return $this->eps;
300			}
301
302			#[Override]
303			public function setEps(int $eps): ColonyInterface
304			{
305			$this->eps = $eps;
306			return $this;
307			}
308
309			#[Override]
310			public function getMaxEps(): int
311			{
312			return $this->max_eps;
313			}
314
315			#[Override]
316			public function setMaxEps(int $max_eps): ColonyInterface
317			{
318			$this->max_eps = $max_eps;
319			return $this;
320			}
321
322			#[Override]
323			public function getMaxStorage(): int
324			{
325			return $this->max_storage;
326			}
327
328			#[Override]
329			public function setMaxStorage(int $max_storage): ColonyInterface
330			{
331			$this->max_storage = $max_storage;
332			return $this;
333			}
334
335			#[Override]
336			public function getMask(): ?string
337			{
338			return $this->mask;
339			}
340
341			#[Override]
342			public function setMask(?string $mask): ColonyInterface
343			{
344			$this->mask = $mask;
345			return $this;
346			}
347
348			#[Override]
349			public function getDatabaseId(): ?int
350			{
351			return $this->database_id;
352			}
353
354			#[Override]
355			public function setDatabaseEntry(?DatabaseEntryInterface $entry): ColonyInterface
356			{
357			$this->databaseEntry = $entry;
358			return $this;
359			}
360
361			#[Override]
362			public function getPopulationlimit(): int
363			{
364			return $this->populationlimit;
365			}
366
367			#[Override]
368			public function setPopulationlimit(int $populationlimit): ColonyInterface
369			{
370			$this->populationlimit = $populationlimit;
371			return $this;
372			}
373
374			#[Override]
375			public function getImmigrationstate(): bool
376			{
377			return $this->immigrationstate;
378			}
379
380			#[Override]
381			public function setImmigrationstate(bool $immigrationstate): ColonyInterface
382			{
383			$this->immigrationstate = $immigrationstate;
384			return $this;
385			}
386
387			#[Override]
388			public function getShields(): ?int
389			{
390			return $this->shields;
391			}
392
393			#[Override]
394			public function setShields(?int $shields): ColonyInterface
395			{
396			$this->shields = $shields;
397			return $this;
398			}
399
400			#[Override]
401			public function getTwilightZone(): int
402			{
403			$twilightZone = 0;
404
405			$width = $this->getSurfaceWidth();
406			$rotationTime = $this->getRotationTime();
407			$colonyTimeSeconds = $this->getColonyTimeSeconds();
408
409			if ($this->getDayTimePrefix() == 1) {
410			$scaled = floor((((100 / ($rotationTime * 0.125)) * ($colonyTimeSeconds - $rotationTime * 0.25)) / 100) * $width);
411			if ($scaled == 0) {
412			$twilightZone = - (($width) - 1);
413			} elseif ((int) - (($width) - ceil($scaled)) == 0) {
414			$twilightZone = -1;
415			} else {
416			$twilightZone = (int) - (($width) - $scaled);
417			}
418			}
419			if ($this->getDayTimePrefix() == 2) {
420			$twilightZone = $width;
421			}
422			if ($this->getDayTimePrefix() == 3) {
423			$scaled = floor((((100 / ($rotationTime * 0.125)) * ($colonyTimeSeconds - $rotationTime * 0.75)) / 100) * $width);
424			$twilightZone = (int) ($width - $scaled);
425			}
426			if ($this->getDayTimePrefix() == 4) {
427			$twilightZone = 0;
428			}
429
430			return $twilightZone;
431			}
432
433			#[Override]
434			public function getShieldFrequency(): ?int
435			{
436			return $this->shield_frequency;
437			}
438
439			#[Override]
440			public function setShieldFrequency(?int $shieldFrequency): ColonyInterface
441			{
442			$this->shield_frequency = $shieldFrequency;
443			return $this;
444			}
445
446			#[Override]
447			public function getTorpedo(): ?TorpedoTypeInterface
448			{
449			return $this->torpedo;
450			}
451
452			#[Override]
453			public function setTorpedo(?TorpedoTypeInterface $torpedoType): ColonyInterface
454			{
455			$this->torpedo = $torpedoType;
456			return $this;
457			}
458
459			#[Override]
460			public function getRotationFactor(): int
461			{
462			return $this->rotation_factor;
463			}
464
465			#[Override]
466			public function setRotationFactor(int $rotationFactor): ColonyInterface
467			{
468			$this->rotation_factor = $rotationFactor;
469
470			return $this;
471			}
472
473			#[Override]
474			public function getRotationTime(): int
475			{
476			return (int) (TimeConstants::ONE_DAY_IN_SECONDS * $this->getRotationFactor() / 100);
477			}
478
479			#[Override]
480			public function getColonyTimeSeconds(): int
481			{
482			return time() % $this->getRotationTime();
483			}
484
485			#[Override]
486			public function getColonyTimeHour(): ?string
487			{
488			$rotationTime = $this->getRotationTime();
489
490			return sprintf("%02d", (int) floor(($rotationTime / 3600) * ($this->getColonyTimeSeconds() / $rotationTime)));
491			}
492
493			#[Override]
494			public function getColonyTimeMinute(): ?string
495			{
496			$rotationTime = $this->getRotationTime();
497
498			return sprintf("%02d", (int) floor(60 * (($rotationTime / 3600) * ($this->getColonyTimeSeconds() / $rotationTime) - ((int) $this->getColonyTimeHour()))));
499			}
500
501			#[Override]
502			public function getDayTimePrefix(): ?int
503			{
504			$daytimeprefix = null;
505			$daypercent = (int) (($this->getColonyTimeSeconds() / $this->getRotationTime()) * 100);
506			if ($daypercent > 25 && $daypercent <= 37.5) {
507			$daytimeprefix = 1; //Sonnenaufgang
508			}
509			if ($daypercent > 37.5 && $daypercent <= 75) {
510			$daytimeprefix = 2; //Tag
511			}
512			if ($daypercent > 75 && $daypercent <= 87.5) {
513			$daytimeprefix = 3; //Sonnenuntergang
514			}
515			if ($daypercent > 87.5 \|\| $daypercent <= 25) {
516			$daytimeprefix = 4; //Nacht
517			}
518			return $daytimeprefix;
519			}
520
521			#[Override]
522			public function getDayTimeName(): ?string
523			{
524			$daytimename = null;
525			if ($this->getDayTimePrefix() == 1) {
526			$daytimename = 'Morgen';
527			}
528
529			if ($this->getDayTimePrefix() == 2) {
530			$daytimename = 'Tag';
531			}
532
533			if ($this->getDayTimePrefix() == 3) {
534			$daytimename = 'Abend';
535			}
536
537			if ($this->getDayTimePrefix() == 4) {
538			$daytimename = 'Nacht';
539			}
540			return $daytimename;
541			}
542
543			#[Override]
544			public function getSurfaceWidth(): int
545			{
546			return $this->surface_width;
547			}
548
549			#[Override]
550			public function setSurfaceWidth(int $surfaceWidth): ColonyInterface
551			{
552			$this->surface_width = $surfaceWidth;
553			return $this;
554			}
555
556			#[Override]
557			public function getColonyClass(): ColonyClassInterface
558			{
559			return $this->colonyClass;
560			}
561
562			#[Override]
563			public function setColonyClass(ColonyClassInterface $colonyClass): ColonyInterface
564			{
565			$this->colonyClass = $colonyClass;
566			return $this;
567			}
568
569			#[Override]
570			public function getStorageSum(): int
571			{
572			return array_reduce(
573			$this->getStorage()->getValues(),
574			fn(int $sum, StorageInterface $storage): int => $sum + $storage->getAmount(),
575			0
576			);
577			}
578
579			#[Override]
580			public function storagePlaceLeft(): bool
581			{
582			return $this->getMaxStorage() > $this->getStorageSum();
583			}
584
585			#[Override]
586			public function getStarsystemMap(): StarSystemMapInterface
587			{
588			return $this->starsystem_map;
589			}
590
591			#[Override]
592			public function setStarsystemMap(StarSystemMapInterface $systemMap): ColonyInterface
593			{
594			$this->starsystem_map = $systemMap;
595
596			return $this;
597			}
598
599			#[Override]
600			public function getSystem(): StarSystemInterface
601			{
602			return $this->getStarsystemMap()->getSystem();
603			}
604
605			#[Override]
606			public function getBeamFactor(): int
607			{
608			return 10;
609			}
610
611			#[Override]
612			public function getPlanetFields(): Collection
613			{
614			return $this->planetFields;
615			}
616
617			/**
618			* @return StorageInterface[]
619			*/
620			#[Override]
621			public function getBeamableStorage(): array
622			{
623			return array_filter(
624			$this->getStorage()->getValues(),
625			fn(StorageInterface $storage): bool => $storage->getCommodity()->isBeamable() === true
626			);
627			}
628
629			#[Override]
630			public function getStorage(): Collection
631			{
632			return $this->storage;
633			}
634
635			#[Override]
636			public function isDefended(): bool
637			{
638			return !$this->getDefenders()->isEmpty();
639			}
640
641			#[Override]
642			public function getDefenders(): Collection
643			{
644			return $this->defenders;
645			}
646
647			#[Override]
648			public function isBlocked(): bool
649			{
650			return !$this->getBlockers()->isEmpty();
651			}
652
653			#[Override]
654			public function getBlockers(): Collection
655			{
656			return $this->blockers;
657			}
658
659			#[Override]
660			public function getCrewAssignments(): Collection
661			{
662			return $this->crewAssignments;
663			}
664
665			#[Override]
666			public function getCrewAssignmentAmount(): int
667			{
668			return $this->crewAssignments->count();
669			}
670
671			#[Override]
672			public function getCrewTrainingAmount(): int
673			{
674			return $this->crewTrainings->count();
675			}
676
677			#[Override]
678			public function getUserDepositMinings(): array
679			{
680			$result = [];
681
682			foreach ($this->depositMinings as $deposit) {
683			if ($deposit->getUser() === $this->getUser()) {
684			$result[$deposit->getCommodity()->getId()] = $deposit;
685			}
686			}
687
688			return $result;
689			}
690
691			#[Override]
692			public function isFree(): bool
693			{
694			return $this->getUserId() === UserEnum::USER_NOONE;
695			}
696
697			#[Override]
698			public function getUser(): UserInterface
699			{
700			return $this->user;
701			}
702
703			#[Override]
704			public function setUser(UserInterface $user): ColonyInterface
705			{
706			$this->user = $user;
707			return $this;
708			}
709
710			#[Override]
711			public function getPopulation(): int
712			{
713			return $this->getWorkers() + $this->getWorkless();
714			}
715
716			#[Override]
717			public function getFreeHousing(): int
718			{
719			return $this->getMaxBev() - $this->getPopulation();
720			}
721
722			#[Override]
723			public function lowerEps(int $value): void
724			{
725			$this->setEps($this->getEps() - $value);
726			}
727
728			#[Override]
729			public function upperEps(int $value): void
730			{
731			$this->setEps($this->getEps() + $value);
732			}
733
734			#[Override]
735			public function getSectorString(): string
736			{
737			return $this->getStarsystemMap()->getSectorString();
738			}
739
740			#[Override]
741			public function getDepositMinings(): Collection
742			{
743			return $this->depositMinings;
744			}
745
746			#[Override]
747			public function getPlanetFieldHostIdentifier(): string
748			{
749			return 'colony';
750			}
751
752			#[Override]
753			public function getPlanetFieldHostColumnIdentifier(): string
754			{
755			return 'colonies_id';
756			}
757
758			#[Override]
759			public function isColony(): bool
760			{
761			return true;
762			}
763
764			#[Override]
765			public function getHostType(): PlanetFieldHostTypeEnum
766			{
767			return PlanetFieldHostTypeEnum::COLONY;
768			}
769
770			#[Override]
771			public function getDefaultViewIdentifier(): string
772			{
773			return ShowColony::VIEW_IDENTIFIER;
774			}
775
776			#[Override]
777			public function isMenuAllowed(ColonyMenuEnum $menu): bool
778			{
779			return true;
780			}
781			}
782

st-universe / core

Push — master ( dfb12b...5aafb2 )

Colony::getColonyClass() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like