Colony::getSystemString() - Code Metrics - Inspection of "Dev" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#2161)

by Janko

created 2025-06-19 19:49 UTC

Colony::getSystemString() A

↳ Parent: Colony

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
ccs	2
cts	2
cp	1
crap	1
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\ModuleEnum;
use Stu\Component\Game\TimeConstants;
filter:
    dependency_paths: ["lib/*"]
use Stu\Lib\Colony\PlanetFieldHostTypeEnum;
use Stu\Lib\Transfer\CommodityTransfer;
use Stu\Lib\Transfer\TransferEntityTypeEnum;
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: '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)]
    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', nullable: false, 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;

    #[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, CrewAssignmentInterface>
     */
    #[OneToMany(targetEntity: 'CrewAssignment', mappedBy: 'colony')]
    private Collection $crewAssignments;

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

    /** @var array<int, int> */
    private array $twilightZones = [];

    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();
    }

    #[Override]
    public function getId(): int
    {
        return $this->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 $timestamp): int
    {
        if (array_key_exists($timestamp, $this->twilightZones)) {
            return $this->twilightZones[$timestamp];
        }

        $twilightZone = 0;

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

        if ($this->getDayTimePrefix($timestamp) == 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($timestamp) == 2) {
            $twilightZone = $width;
        }
        if ($this->getDayTimePrefix($timestamp) == 3) {
            $scaled = floor((((100 / ($rotationTime * 0.125)) * ($colonyTimeSeconds - $rotationTime * 0.75)) / 100) * $width);
            $twilightZone = (int) ($width - $scaled);
        }
        if ($this->getDayTimePrefix($timestamp) == 4) {
            $twilightZone = 0;
        }

        $this->twilightZones[$timestamp] = $twilightZone;

        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);
    }

    public function getColonyTimeSeconds(int $timestamp): int
    {
        return $timestamp % $this->getRotationTime();
    }

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

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

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

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

    #[Override]
    public function getDayTimePrefix(int $timestamp): ?int
    {
        $daytimeprefix = null;
        $daypercent = (int) (($this->getColonyTimeSeconds($timestamp) / $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(int $timestamp): ?string
    {
        $daytimename = null;
        if ($this->getDayTimePrefix($timestamp) == 1) {
            $daytimename = 'Morgen';
        }

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

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

        if ($this->getDayTimePrefix($timestamp) == 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 getLocation(): MapInterface|StarSystemMapInterface
    {
        return $this->getStarsystemMap();
    }

    #[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;
    }

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

    #[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 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 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;
    }

    #[Override]
    public function getTransferEntityType(): TransferEntityTypeEnum
    {
        return TransferEntityTypeEnum::COLONY;
    }

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

    #[Override]
    public function getComponentParameters(): string
    {
        return sprintf(
            '&hosttype=%d&id=%d',
            $this->getHostType()->value,
            $this->getId()
        );
    }
}


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

st-universe / core

Pull Request — master (#2161)

Colony::getSystemString() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like