SmrGalaxy::getMaxForceTime() - Code Metrics - smrealms/smr - Measure and Improve Code Quality continuously with Scrutinizer

SmrGalaxy::getMaxForceTime() A
last analyzed 2023-01-09 04:33 UTC

↳ Parent: SmrGalaxy

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	1
dl	0
loc	2
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php declare(strict_types=1);

use Smr\Database;
use Smr\DatabaseRecord;
use Smr\Exceptions\GalaxyNotFound;

class SmrGalaxy {

	/** @var array<int, array<int, self>> */
	protected static array $CACHE_GALAXIES = [];
	/** @var array<int, array<int, self>> */
	protected static array $CACHE_GAME_GALAXIES = [];

	public const TYPE_RACIAL = 'Racial';
	public const TYPE_NEUTRAL = 'Neutral';
	public const TYPE_PLANET = 'Planet';
	public const TYPES = [self::TYPE_RACIAL, self::TYPE_NEUTRAL, self::TYPE_PLANET];

	protected Database $db;
	protected readonly string $SQL;

	protected string $name;
	protected int $width;
	protected int $height;
	protected string $galaxyType;
	protected int $maxForceTime;

	protected int $startSector;

	protected bool $hasChanged = false;
	protected bool $isNew;

	public static function clearCache(): void {
		self::$CACHE_GALAXIES = [];
		self::$CACHE_GAME_GALAXIES = [];
	}

	/**
	 * @return array<int, self>
	 */
	public static function getGameGalaxies(int $gameID, bool $forceUpdate = false): array {
		if ($forceUpdate || !isset(self::$CACHE_GAME_GALAXIES[$gameID])) {
			$db = Database::getInstance();
			$dbResult = $db->read('SELECT * FROM game_galaxy WHERE game_id = ' . $db->escapeNumber($gameID) . ' ORDER BY galaxy_id ASC');
			$galaxies = [];
			foreach ($dbResult->records() as $dbRecord) {
				$galaxyID = $dbRecord->getInt('galaxy_id');
				$galaxies[$galaxyID] = self::getGalaxy($gameID, $galaxyID, $forceUpdate, $dbRecord);
			}
			self::$CACHE_GAME_GALAXIES[$gameID] = $galaxies;
		}
		return self::$CACHE_GAME_GALAXIES[$gameID];
	}

	public static function getGalaxy(int $gameID, int $galaxyID, bool $forceUpdate = false, DatabaseRecord $dbRecord = null): self {
		if ($forceUpdate || !isset(self::$CACHE_GALAXIES[$gameID][$galaxyID])) {
			$g = new self($gameID, $galaxyID, false, $dbRecord);
			self::$CACHE_GALAXIES[$gameID][$galaxyID] = $g;
		}
		return self::$CACHE_GALAXIES[$gameID][$galaxyID];
	}

	public static function saveGalaxies(): void {
		foreach (self::$CACHE_GALAXIES as $gameGalaxies) {
			foreach ($gameGalaxies as $galaxy) {
				$galaxy->save();
			}
		}
	}

	public static function createGalaxy(int $gameID, int $galaxyID): self {
		if (!isset(self::$CACHE_GALAXIES[$gameID][$galaxyID])) {
			$g = new self($gameID, $galaxyID, true);
			self::$CACHE_GALAXIES[$gameID][$galaxyID] = $g;
		}
		return self::$CACHE_GALAXIES[$gameID][$galaxyID];
	}

	protected function __construct(
		protected readonly int $gameID,
		protected readonly int $galaxyID,
		bool $create = false,
		DatabaseRecord $dbRecord = null
	) {
		$this->db = Database::getInstance();
		$this->SQL = 'game_id = ' . $this->db->escapeNumber($gameID) . '

		              AND galaxy_id = ' . $this->db->escapeNumber($galaxyID);

		if ($dbRecord === null) {
			$dbResult = $this->db->read('SELECT * FROM game_galaxy WHERE ' . $this->SQL);
			if ($dbResult->hasRecord()) {
				$dbRecord = $dbResult->record();
			}
		}
		$this->isNew = $dbRecord === null;

		if (!$this->isNew) {
			$this->name = $dbRecord->getString('galaxy_name');
			$this->width = $dbRecord->getInt('width');
			$this->height = $dbRecord->getInt('height');
			$this->galaxyType = $dbRecord->getString('galaxy_type');
			$this->maxForceTime = $dbRecord->getInt('max_force_time');
		} elseif ($create === false) {
			throw new GalaxyNotFound('No such galaxy: ' . $gameID . '-' . $galaxyID);
		}
	}

	public function save(): void {
		if ($this->isNew) {
			$this->db->insert('game_galaxy', [
				'game_id' => $this->db->escapeNumber($this->getGameID()),
				'galaxy_id' => $this->db->escapeNumber($this->getGalaxyID()),
				'galaxy_name' => $this->db->escapeString($this->getName()),
				'width' => $this->db->escapeNumber($this->getWidth()),
				'height' => $this->db->escapeNumber($this->getHeight()),
				'galaxy_type' => $this->db->escapeString($this->getGalaxyType()),
				'max_force_time' => $this->db->escapeNumber($this->getMaxForceTime()),
			]);
		} elseif ($this->hasChanged) {
			$this->db->write('UPDATE game_galaxy SET galaxy_name = ' . $this->db->escapeString($this->getName()) .
										', width = ' . $this->db->escapeNumber($this->getWidth()) .
										', height = ' . $this->db->escapeNumber($this->getHeight()) .
										', galaxy_type = ' . $this->db->escapeString($this->getGalaxyType()) .
										', max_force_time = ' . $this->db->escapeNumber($this->getMaxForceTime()) .
									' WHERE ' . $this->SQL);
		}
		$this->isNew = false;
		$this->hasChanged = false;
	}

	public function getGameID(): int {
		return $this->gameID;
	}

	public function getGalaxyID(): int {
		return $this->galaxyID;
	}

	public function getGalaxyMapHREF(): string {
		return 'map_galaxy.php?galaxy_id=' . $this->getGalaxyID();
	}

	/**
	 * Returns the galaxy name.
	 * Use getDisplayName for an HTML-safe version.
	 */
	public function getName(): string {
		return $this->name;
	}

	/**
	 * Returns the galaxy name, suitable for HTML display.
	 */
	public function getDisplayName(): string {
		return htmlentities($this->name);
	}

	public function setName(string $name): void {
		if (!$this->isNew && $this->name === $name) {
			return;
		}
		$this->name = $name;
		$this->hasChanged = true;
	}

	public function getWidth(): int {
		return $this->width;
	}

	public function setWidth(int $width): void {
		if (!$this->isNew && $this->width === $width) {
			return;
		}
		$this->width = $width;
		$this->hasChanged = true;
	}

	public function getHeight(): int {
		return $this->height;
	}

	public function setHeight(int $height): void {
		if (!$this->isNew && $this->height === $height) {
			return;
		}
		$this->height = $height;
		$this->hasChanged = true;
	}

	public function getStartSector(): int {
		if (!isset($this->startSector)) {
			$this->startSector = 1;
			if ($this->galaxyID != 1) {
				$galaxies = self::getGameGalaxies($this->gameID);
				for ($i = 1; $i < $this->galaxyID; $i++) {
					$this->startSector += $galaxies[$i]->getSize();
				}
			}
		}
		return $this->startSector;
	}

	public function getEndSector(): int {
		return $this->getStartSector() + $this->getSize() - 1;
	}

	public function getSize(): int {
		return $this->getHeight() * $this->getWidth();
	}

	/**
	 * @return array<int, SmrSector>
	 */
	public function getSectors(): array {
		return SmrSector::getGalaxySectors($this->getGameID(), $this->getGalaxyID());
	}

	/**
	 * @return array<int, SmrPort>
	 */
	public function getPorts(): array {
		return SmrPort::getGalaxyPorts($this->getGameID(), $this->getGalaxyID());
	}

	/**
	 * @return array<int, array<int, SmrLocation>>
	 */
	public function getLocations(): array {
		return SmrLocation::getGalaxyLocations($this->getGameID(), $this->getGalaxyID());
	}

	/**
	 * @return array<int, SmrPlanet>
	 */
	public function getPlanets(): array {
		return SmrPlanet::getGalaxyPlanets($this->getGameID(), $this->getGalaxyID());
	}

	/**
	 * @return array<int, array<int, SmrForce>>
	 */
	public function getForces(): array {
		return SmrForce::getGalaxyForces($this->getGameID(), $this->getGalaxyID());
	}

	/**
	 * @return array<int, array<int, SmrPlayer>>
	 */
	public function getPlayers(): array {
		return SmrPlayer::getGalaxyPlayers($this->getGameID(), $this->getGalaxyID());
	}

	/**
	 * Returns a 2D array of sectors in the galaxy.
	 * If $centerSectorID is specified, it will be in the center of the array.
	 * If $dist is also specified, only include sectors $dist away from center.
	 *
	 * NOTE: This routine queries sectors inefficiently. You may want to
	 * construct the cache efficiently before calling this.
	 *
	 * @return array<int, array<int, SmrSector>>
	 */
	public function getMapSectors(int $centerSectorID = null, int $dist = null): array {
		if ($centerSectorID === null) {
			$topLeft = SmrSector::getSector($this->getGameID(), $this->getStartSector());
		} else {
			$topLeft = SmrSector::getSector($this->getGameID(), $centerSectorID);
			// go left then up
			$halfWidth = floor($this->width / 2);
			for ($i = 0; ($dist === null || $i < $dist) && $i < $halfWidth; $i++) {
				$topLeft = $topLeft->getNeighbourSector('Left');
			}
			$halfHeight = floor($this->height / 2);
			for ($i = 0; ($dist === null || $i < $dist) && $i < $halfHeight; $i++) {
				$topLeft = $topLeft->getNeighbourSector('Up');
			}
		}

		$mapSectors = [];
		$rowLeft = $topLeft;
		for ($i = 0; ($dist === null || $i < 2 * $dist + 1) && $i < $this->height; $i++) {
			$mapSectors[$i] = [];
			// get left most sector for this row
			if ($i > 0) {
				$rowLeft = $rowLeft->getNeighbourSector('Down');
			}

			// iterate through the columns
			$nextSector = $rowLeft;
			for ($j = 0; ($dist === null || $j < 2 * $dist + 1) && $j < $this->width; $j++) {
				if ($j > 0) {
					$nextSector = $nextSector->getNeighbourSector('Right');
				}
				$mapSectors[$i][$j] = $nextSector;
			}
		}
		return $mapSectors;
	}

	public function getGalaxyType(): string {
		return $this->galaxyType;
	}

	public function setGalaxyType(string $galaxyType): void {
		if (!$this->isNew && $this->galaxyType === $galaxyType) {
			return;
		}
		$this->galaxyType = $galaxyType;
		$this->hasChanged = true;
	}

	public function getMaxForceTime(): int {
		return $this->maxForceTime;
	}

	public function setMaxForceTime(int $maxForceTime): void {
		if (!$this->isNew && $this->maxForceTime === $maxForceTime) {
			return;
		}
		$this->maxForceTime = $maxForceTime;
		$this->hasChanged = true;
	}

	public function generateSectors(): void {
		$sectorID = $this->getStartSector();
		$galSize = $this->getSize();
		for ($i = 0; $i < $galSize; $i++) {
			$sector = SmrSector::createSector($this->gameID, $sectorID);
			$sector->setGalaxyID($this->getGalaxyID());
			$sector->update(); //Have to save sectors after creating them
			$sectorID++;
		}
		$this->setConnectivity(100);
	}

	/**
	 * Randomly set the connections between all galaxy sectors.
	 * $connectivity = (average) percent of connections to enable.
	 */
	public function setConnectivity(float $connectivity): bool {
		// Only set down/right, otherwise we double-hit every link
		$linkDirs = ['Down', 'Right'];

		$problem = true;
		$problemTimes = 0;
		while ($problem) {
			$problem = false;

			foreach ($this->getSectors() as $galSector) {
				foreach ($linkDirs as $linkDir) {
					if (rand(1, 100) <= $connectivity) {
						$galSector->enableLink($linkDir);
					} else {
						$galSector->disableLink($linkDir);
					}
				}
			}

			// Try again if any sector has 0 connections (except 1-sector gals)
			if ($this->getSize() > 1) {
				foreach ($this->getSectors() as $galSector) {
					if ($galSector->getNumberOfConnections() == 0) {
						$problem = true;
						break;
					}
				}
			}

			if ($problem && $problemTimes++ > 350) {
				$connectivity = 100;
			}
		}
		return $problemTimes <= 350;
	}

	/**
	 * Returns the sector connectivity of the galaxy as a percent.
	 */
	public function getConnectivity(): float {
		$totalLinks = 0;
		foreach ($this->getSectors() as $galSector) {
			$totalLinks += $galSector->getNumberOfLinks();
		}
		// There are 4 possible links per sector
		return 100 * $totalLinks / (4 * $this->getSize());
	}

	/**
	 * Check if the galaxy contains a specific sector.
	 */
	public function contains(int|SmrSector $sectorID): bool {
		if ($sectorID instanceof SmrSector) {
			return $sectorID->getGalaxyID() == $this->getGalaxyID();
		}
		return $sectorID >= $this->getStartSector() && $sectorID <= $this->getEndSector();
	}

	public static function getGalaxyContaining(int $gameID, int $sectorID): self {
		return SmrSector::getSector($gameID, $sectorID)->getGalaxy();
	}

	public function equals(SmrGalaxy $otherGalaxy): bool {
		return $otherGalaxy->getGalaxyID() == $this->getGalaxyID() && $otherGalaxy->getGameID() == $this->getGameID();
	}

}


1			<?php declare(strict_types=1);
2
3			use Smr\Database;
4			use Smr\DatabaseRecord;
5			use Smr\Exceptions\GalaxyNotFound;
6
7			class SmrGalaxy {
8
9			/** @var array<int, array<int, self>> */
10			protected static array $CACHE_GALAXIES = [];
11			/** @var array<int, array<int, self>> */
12			protected static array $CACHE_GAME_GALAXIES = [];
13
14			public const TYPE_RACIAL = 'Racial';
15			public const TYPE_NEUTRAL = 'Neutral';
16			public const TYPE_PLANET = 'Planet';
17			public const TYPES = [self::TYPE_RACIAL, self::TYPE_NEUTRAL, self::TYPE_PLANET];
18
19			protected Database $db;
20			protected readonly string $SQL;
21
22			protected string $name;
23			protected int $width;
24			protected int $height;
25			protected string $galaxyType;
26			protected int $maxForceTime;
27
28			protected int $startSector;
29
30			protected bool $hasChanged = false;
31			protected bool $isNew;
32
33			public static function clearCache(): void {
34			self::$CACHE_GALAXIES = [];
35			self::$CACHE_GAME_GALAXIES = [];
36			}
37
38			/**
39			* @return array<int, self>
40			*/
41			public static function getGameGalaxies(int $gameID, bool $forceUpdate = false): array {
42			if ($forceUpdate \|\| !isset(self::$CACHE_GAME_GALAXIES[$gameID])) {
43			$db = Database::getInstance();
44			$dbResult = $db->read('SELECT * FROM game_galaxy WHERE game_id = ' . $db->escapeNumber($gameID) . ' ORDER BY galaxy_id ASC');
45			$galaxies = [];
46			foreach ($dbResult->records() as $dbRecord) {
47			$galaxyID = $dbRecord->getInt('galaxy_id');
48			$galaxies[$galaxyID] = self::getGalaxy($gameID, $galaxyID, $forceUpdate, $dbRecord);
49			}
50			self::$CACHE_GAME_GALAXIES[$gameID] = $galaxies;
51			}
52			return self::$CACHE_GAME_GALAXIES[$gameID];
53			}
54
55			public static function getGalaxy(int $gameID, int $galaxyID, bool $forceUpdate = false, DatabaseRecord $dbRecord = null): self {
56			if ($forceUpdate \|\| !isset(self::$CACHE_GALAXIES[$gameID][$galaxyID])) {
57			$g = new self($gameID, $galaxyID, false, $dbRecord);
58			self::$CACHE_GALAXIES[$gameID][$galaxyID] = $g;
59			}
60			return self::$CACHE_GALAXIES[$gameID][$galaxyID];
61			}
62
63			public static function saveGalaxies(): void {
64			foreach (self::$CACHE_GALAXIES as $gameGalaxies) {
65			foreach ($gameGalaxies as $galaxy) {
66			$galaxy->save();
67			}
68			}
69			}
70
71			public static function createGalaxy(int $gameID, int $galaxyID): self {
72			if (!isset(self::$CACHE_GALAXIES[$gameID][$galaxyID])) {
73			$g = new self($gameID, $galaxyID, true);
74			self::$CACHE_GALAXIES[$gameID][$galaxyID] = $g;
75			}
76			return self::$CACHE_GALAXIES[$gameID][$galaxyID];
77			}
78
79			protected function __construct(
80			protected readonly int $gameID,
81			protected readonly int $galaxyID,
82			bool $create = false,
83			DatabaseRecord $dbRecord = null
84			) {
85			$this->db = Database::getInstance();
86			$this->SQL = 'game_id = ' . $this->db->escapeNumber($gameID) . '
			0 ignored issues – show Bug introduced 2022-05-28 05:21 UTC by Report Bug Copy Issue Report The property `SQL` is declared read-only in `SmrGalaxy`. Loading history...
87			AND galaxy_id = ' . $this->db->escapeNumber($galaxyID);
88
89			if ($dbRecord === null) {
90			$dbResult = $this->db->read('SELECT * FROM game_galaxy WHERE ' . $this->SQL);
91			if ($dbResult->hasRecord()) {
92			$dbRecord = $dbResult->record();
93			}
94			}
95			$this->isNew = $dbRecord === null;
96
97			if (!$this->isNew) {
98			$this->name = $dbRecord->getString('galaxy_name');
99			$this->width = $dbRecord->getInt('width');
100			$this->height = $dbRecord->getInt('height');
101			$this->galaxyType = $dbRecord->getString('galaxy_type');
102			$this->maxForceTime = $dbRecord->getInt('max_force_time');
103			} elseif ($create === false) {
104			throw new GalaxyNotFound('No such galaxy: ' . $gameID . '-' . $galaxyID);
105			}
106			}
107
108			public function save(): void {
109			if ($this->isNew) {
110			$this->db->insert('game_galaxy', [
111			'game_id' => $this->db->escapeNumber($this->getGameID()),
112			'galaxy_id' => $this->db->escapeNumber($this->getGalaxyID()),
113			'galaxy_name' => $this->db->escapeString($this->getName()),
114			'width' => $this->db->escapeNumber($this->getWidth()),
115			'height' => $this->db->escapeNumber($this->getHeight()),
116			'galaxy_type' => $this->db->escapeString($this->getGalaxyType()),
117			'max_force_time' => $this->db->escapeNumber($this->getMaxForceTime()),
118			]);
119			} elseif ($this->hasChanged) {
120			$this->db->write('UPDATE game_galaxy SET galaxy_name = ' . $this->db->escapeString($this->getName()) .
121			', width = ' . $this->db->escapeNumber($this->getWidth()) .
122			', height = ' . $this->db->escapeNumber($this->getHeight()) .
123			', galaxy_type = ' . $this->db->escapeString($this->getGalaxyType()) .
124			', max_force_time = ' . $this->db->escapeNumber($this->getMaxForceTime()) .
125			' WHERE ' . $this->SQL);
126			}
127			$this->isNew = false;
128			$this->hasChanged = false;
129			}
130
131			public function getGameID(): int {
132			return $this->gameID;
133			}
134
135			public function getGalaxyID(): int {
136			return $this->galaxyID;
137			}
138
139			public function getGalaxyMapHREF(): string {
140			return 'map_galaxy.php?galaxy_id=' . $this->getGalaxyID();
141			}
142
143			/**
144			* Returns the galaxy name.
145			* Use getDisplayName for an HTML-safe version.
146			*/
147			public function getName(): string {
148			return $this->name;
149			}
150
151			/**
152			* Returns the galaxy name, suitable for HTML display.
153			*/
154			public function getDisplayName(): string {
155			return htmlentities($this->name);
156			}
157
158			public function setName(string $name): void {
159			if (!$this->isNew && $this->name === $name) {
160			return;
161			}
162			$this->name = $name;
163			$this->hasChanged = true;
164			}
165
166			public function getWidth(): int {
167			return $this->width;
168			}
169
170			public function setWidth(int $width): void {
171			if (!$this->isNew && $this->width === $width) {
172			return;
173			}
174			$this->width = $width;
175			$this->hasChanged = true;
176			}
177
178			public function getHeight(): int {
179			return $this->height;
180			}
181
182			public function setHeight(int $height): void {
183			if (!$this->isNew && $this->height === $height) {
184			return;
185			}
186			$this->height = $height;
187			$this->hasChanged = true;
188			}
189
190			public function getStartSector(): int {
191			if (!isset($this->startSector)) {
192			$this->startSector = 1;
193			if ($this->galaxyID != 1) {
194			$galaxies = self::getGameGalaxies($this->gameID);
195			for ($i = 1; $i < $this->galaxyID; $i++) {
196			$this->startSector += $galaxies[$i]->getSize();
197			}
198			}
199			}
200			return $this->startSector;
201			}
202
203			public function getEndSector(): int {
204			return $this->getStartSector() + $this->getSize() - 1;
205			}
206
207			public function getSize(): int {
208			return $this->getHeight() * $this->getWidth();
209			}
210
211			/**
212			* @return array<int, SmrSector>
213			*/
214			public function getSectors(): array {
215			return SmrSector::getGalaxySectors($this->getGameID(), $this->getGalaxyID());
216			}
217
218			/**
219			* @return array<int, SmrPort>
220			*/
221			public function getPorts(): array {
222			return SmrPort::getGalaxyPorts($this->getGameID(), $this->getGalaxyID());
223			}
224
225			/**
226			* @return array<int, array<int, SmrLocation>>
227			*/
228			public function getLocations(): array {
229			return SmrLocation::getGalaxyLocations($this->getGameID(), $this->getGalaxyID());
230			}
231
232			/**
233			* @return array<int, SmrPlanet>
234			*/
235			public function getPlanets(): array {
236			return SmrPlanet::getGalaxyPlanets($this->getGameID(), $this->getGalaxyID());
237			}
238
239			/**
240			* @return array<int, array<int, SmrForce>>
241			*/
242			public function getForces(): array {
243			return SmrForce::getGalaxyForces($this->getGameID(), $this->getGalaxyID());
244			}
245
246			/**
247			* @return array<int, array<int, SmrPlayer>>
248			*/
249			public function getPlayers(): array {
250			return SmrPlayer::getGalaxyPlayers($this->getGameID(), $this->getGalaxyID());
251			}
252
253			/**
254			* Returns a 2D array of sectors in the galaxy.
255			* If $centerSectorID is specified, it will be in the center of the array.
256			* If $dist is also specified, only include sectors $dist away from center.
257			*
258			* NOTE: This routine queries sectors inefficiently. You may want to
259			* construct the cache efficiently before calling this.
260			*
261			* @return array<int, array<int, SmrSector>>
262			*/
263			public function getMapSectors(int $centerSectorID = null, int $dist = null): array {
264			if ($centerSectorID === null) {
265			$topLeft = SmrSector::getSector($this->getGameID(), $this->getStartSector());
266			} else {
267			$topLeft = SmrSector::getSector($this->getGameID(), $centerSectorID);
268			// go left then up
269			$halfWidth = floor($this->width / 2);
270			for ($i = 0; ($dist === null \|\| $i < $dist) && $i < $halfWidth; $i++) {
271			$topLeft = $topLeft->getNeighbourSector('Left');
272			}
273			$halfHeight = floor($this->height / 2);
274			for ($i = 0; ($dist === null \|\| $i < $dist) && $i < $halfHeight; $i++) {
275			$topLeft = $topLeft->getNeighbourSector('Up');
276			}
277			}
278
279			$mapSectors = [];
280			$rowLeft = $topLeft;
281			for ($i = 0; ($dist === null \|\| $i < 2 * $dist + 1) && $i < $this->height; $i++) {
282			$mapSectors[$i] = [];
283			// get left most sector for this row
284			if ($i > 0) {
285			$rowLeft = $rowLeft->getNeighbourSector('Down');
286			}
287
288			// iterate through the columns
289			$nextSector = $rowLeft;
290			for ($j = 0; ($dist === null \|\| $j < 2 * $dist + 1) && $j < $this->width; $j++) {
291			if ($j > 0) {
292			$nextSector = $nextSector->getNeighbourSector('Right');
293			}
294			$mapSectors[$i][$j] = $nextSector;
295			}
296			}
297			return $mapSectors;
298			}
299
300			public function getGalaxyType(): string {
301			return $this->galaxyType;
302			}
303
304			public function setGalaxyType(string $galaxyType): void {
305			if (!$this->isNew && $this->galaxyType === $galaxyType) {
306			return;
307			}
308			$this->galaxyType = $galaxyType;
309			$this->hasChanged = true;
310			}
311
312			public function getMaxForceTime(): int {
313			return $this->maxForceTime;
314			}
315
316			public function setMaxForceTime(int $maxForceTime): void {
317			if (!$this->isNew && $this->maxForceTime === $maxForceTime) {
318			return;
319			}
320			$this->maxForceTime = $maxForceTime;
321			$this->hasChanged = true;
322			}
323
324			public function generateSectors(): void {
325			$sectorID = $this->getStartSector();
326			$galSize = $this->getSize();
327			for ($i = 0; $i < $galSize; $i++) {
328			$sector = SmrSector::createSector($this->gameID, $sectorID);
329			$sector->setGalaxyID($this->getGalaxyID());
330			$sector->update(); //Have to save sectors after creating them
331			$sectorID++;
332			}
333			$this->setConnectivity(100);
334			}
335
336			/**
337			* Randomly set the connections between all galaxy sectors.
338			* $connectivity = (average) percent of connections to enable.
339			*/
340			public function setConnectivity(float $connectivity): bool {
341			// Only set down/right, otherwise we double-hit every link
342			$linkDirs = ['Down', 'Right'];
343
344			$problem = true;
345			$problemTimes = 0;
346			while ($problem) {
347			$problem = false;
348
349			foreach ($this->getSectors() as $galSector) {
350			foreach ($linkDirs as $linkDir) {
351			if (rand(1, 100) <= $connectivity) {
352			$galSector->enableLink($linkDir);
353			} else {
354			$galSector->disableLink($linkDir);
355			}
356			}
357			}
358
359			// Try again if any sector has 0 connections (except 1-sector gals)
360			if ($this->getSize() > 1) {
361			foreach ($this->getSectors() as $galSector) {
362			if ($galSector->getNumberOfConnections() == 0) {
363			$problem = true;
364			break;
365			}
366			}
367			}
368
369			if ($problem && $problemTimes++ > 350) {
370			$connectivity = 100;
371			}
372			}
373			return $problemTimes <= 350;
374			}
375
376			/**
377			* Returns the sector connectivity of the galaxy as a percent.
378			*/
379			public function getConnectivity(): float {
380			$totalLinks = 0;
381			foreach ($this->getSectors() as $galSector) {
382			$totalLinks += $galSector->getNumberOfLinks();
383			}
384			// There are 4 possible links per sector
385			return 100 * $totalLinks / (4 * $this->getSize());
386			}
387
388			/**
389			* Check if the galaxy contains a specific sector.
390			*/
391			public function contains(int\|SmrSector $sectorID): bool {
392			if ($sectorID instanceof SmrSector) {
393			return $sectorID->getGalaxyID() == $this->getGalaxyID();
394			}
395			return $sectorID >= $this->getStartSector() && $sectorID <= $this->getEndSector();
396			}
397
398			public static function getGalaxyContaining(int $gameID, int $sectorID): self {
399			return SmrSector::getSector($gameID, $sectorID)->getGalaxy();
400			}
401
402			public function equals(SmrGalaxy $otherGalaxy): bool {
403			return $otherGalaxy->getGalaxyID() == $this->getGalaxyID() && $otherGalaxy->getGameID() == $this->getGameID();
404			}
405
406			}
407

smrealms / smr

Scrutinizer GitHub App not installed

SmrGalaxy::getMaxForceTime() A last analyzed 2023-01-09 04:33 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SmrGalaxy::getMaxForceTime() A
last analyzed 2023-01-09 04:33 UTC