ChessPiece::getPossibleMoves() - Code Metrics - Inspection of "Merge pull request #1072 from hemberger/typehints" - smrealms/smr - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( 9c91a5...05804d )

by Dan

created 2021-06-06 01:57 UTC

ChessPiece::getPossibleMoves() F

↳ Parent: ChessPiece

Complexity

Conditions	76
Paths	25

Size

Total Lines	125
Code Lines	106

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	76
eloc	106
c	1
b	0
f	1
nc	25
nop	4
dl	0
loc	125
rs	3.3333

How to fix Long Method Complexity

<?php declare(strict_types=1);

class ChessPiece {
	const KING = 1;
	const QUEEN = 2;
	const ROOK = 3;
	const BISHOP = 4;
	const KNIGHT = 5;
	const PAWN = 6;

	public function __construct(
		public int $chessGameID,
		public int $accountID,
		public string $colour,
		public int $pieceID,
		public int $x,
		public int $y,
		public int $pieceNo = -1) {
	}

	public function isSafeMove(array &$board, array &$hasMoved, int $toX = -1, int $toY = -1) : bool {
		$x = $this->x;
		$y = $this->y;
		$moveInfo = ChessGame::movePiece($board, $hasMoved, $x, $y, $toX, $toY);
		$safe = !ChessGame::isPlayerChecked($board, $hasMoved, $this->colour);
		ChessGame::undoMovePiece($board, $hasMoved, $x, $y, $toX, $toY, $moveInfo);
		return $safe;
	}

	public function isAttacking(array &$board, array &$hasMoved, bool $king, int $x = -1, int $y = -1) : bool {
		$moves = $this->getPossibleMoves($board, $hasMoved, null, true);
		foreach ($moves as $move) {
			$p = $board[$move[1]][$move[0]];
			if (($move[0] == $x && $move[1] == $y) || ($king === true && $p != null && $p->pieceID == self::KING && $this->colour != $p->colour)) {
				return true;
			}
		}
		return false;
	}

	public function getPossibleMoves(array &$board, array &$hasMoved, int $forAccountID = null, bool $attackingCheck = false) : array {
		$moves = array();
		if ($forAccountID === null || $this->accountID == $forAccountID) {
			if ($this->pieceID == self::PAWN) {
				$dirY = $this->colour == ChessGame::PLAYER_BLACK ? 1 : -1;
				$moveY = $this->y + $dirY;
				//Pawn forward movement is not attacking - so don't check it if doing an attacking check.
				if (!$attackingCheck) {
					if (ChessGame::isValidCoord($this->x, $moveY, $board) && $board[$moveY][$this->x] === null && $this->isSafeMove($board, $hasMoved, $this->x, $moveY)) {
						$moves[] = array($this->x, $moveY);
					}
					$doubleMoveY = $moveY + $dirY;
					if ($this->y - $dirY == 0 || $this->y - $dirY * 2 == count($board)) { //Double move first move
						if ($board[$moveY][$this->x] === null && $board[$doubleMoveY][$this->x] === null && $this->isSafeMove($board, $hasMoved, $this->x, $doubleMoveY)) {
							$moves[] = array($this->x, $doubleMoveY);
						}
					}
				}
				for ($i = -1; $i < 2; $i += 2) {
					$moveX = $this->x + $i;
					if (ChessGame::isValidCoord($moveX, $moveY, $board)) {
						if ($attackingCheck ||
							((($hasMoved[ChessPiece::PAWN][0] == $moveX && $hasMoved[ChessPiece::PAWN][1] == $this->y) ||
							($board[$moveY][$moveX] != null && $board[$moveY][$moveX]->colour != $this->colour))
							&& $this->isSafeMove($board, $hasMoved, $moveX, $moveY))) {
							$moves[] = array($moveX, $moveY);
						}
					}
				}
			} elseif ($this->pieceID == self::KING) {
				for ($i = -1; $i < 2; $i++) {
					for ($j = -1; $j < 2; $j++) {
						if ($i != 0 || $j != 0) {
							$this->addMove($this->x + $i, $this->y + $j, $board, $moves, $hasMoved, $attackingCheck);
						}
					}
				}
				//Castling is not attacking - so don't check it if doing an attacking check.
				if (!$attackingCheck && !$hasMoved[$this->colour][ChessPiece::KING] && !ChessGame::isPlayerChecked($board, $hasMoved, $this->colour)) {
					if (!$hasMoved[$this->colour][ChessPiece::ROOK]['Queen'] &&
							ChessGame::isValidCoord($this->x - 1, $this->y, $board) && $board[$this->y][$this->x - 1] === null &&
							ChessGame::isValidCoord($this->x - 3, $this->y, $board) && $board[$this->y][$this->x - 3] === null &&
							$this->isSafeMove($board, $hasMoved, $this->x - 1, $this->y)) {
						$this->addMove($this->x - 2, $this->y, $board, $moves, $hasMoved, $attackingCheck);
					}
					if (!$hasMoved[$this->colour][ChessPiece::ROOK]['King'] &&
							ChessGame::isValidCoord($this->x + 1, $this->y, $board) && $board[$this->y][$this->x + 1] === null &&
							$this->isSafeMove($board, $hasMoved, $this->x + 1, $this->y)) {
						$this->addMove($this->x + 2, $this->y, $board, $moves, $hasMoved, $attackingCheck);
					}
				}
			} elseif ($this->pieceID == self::QUEEN) {
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(--$moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Left
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(++$moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Right
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove($moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove($moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Down
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(--$moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Left
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(++$moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Right
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(--$moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Down-Left
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(++$moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Left
			} elseif ($this->pieceID == self::ROOK) {
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(--$moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Left
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(++$moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Right
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove($moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove($moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Down
			} elseif ($this->pieceID == self::BISHOP) {
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(--$moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Left
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(++$moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Right
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(--$moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Down-Left
				$moveX = $this->x;
				$moveY = $this->y;
				while ($this->addMove(++$moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Left
			} elseif ($this->pieceID == self::KNIGHT) {
				$moveX = $this->x - 1;
				$moveY = $this->y - 2;
				$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2up-left
				$moveX += 2;
				$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2up-right
				$moveY = $this->y + 2;
				$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2down-right
				$moveX -= 2;
				$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2down-left
				$moveX = $this->x - 2;
				$moveY = $this->y - 1;
				$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2left-up
				$moveY += 2;
				$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2left-down
				$moveX = $this->x + 2;
				$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2right-down
				$moveY -= 2;
				$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2right-up
			}
		}

		return $moves;
	}

	private function addMove(int $toX, int $toY, array &$board, array &$moves, array &$hasMoved, bool $attackingCheck = true) : bool {
		if (ChessGame::isValidCoord($toX, $toY, $board)) {
			if (($board[$toY][$toX] === null || $board[$toY][$toX]->colour != $this->colour)) {
				//We can only actually move to this position if it is safe to do so, however we can pass through it looking for a safe move so we still want to return true.
				if (($attackingCheck === true || $this->isSafeMove($board, $hasMoved, $toX, $toY))) {
					$moves[] = array($toX, $toY);
				}
				return true;
			}
		}
		return false;
	}

	public function promote(int $pawnPromotionPieceID, array &$board) : array {
		$takenNos = array();
		foreach ($board as $row) {
			foreach ($row as $piece) {
				if ($piece != null && $piece->pieceID == $pawnPromotionPieceID && $piece->colour == $this->colour) {
					$takenNos[$piece->pieceNo] = true;
				}
			}
		}
		$i = 0;
		while (isset($takenNos[$i])) {
			$i++;
		}
		return array('PieceID' => $pawnPromotionPieceID, 'PieceNo' => $i);
	}

	public function getPieceLetter() : string {
		return self::getLetterForPiece($this->pieceID, $this->colour);
	}

	public function getPieceSymbol() : string {
		return self::getSymbolForPiece($this->pieceID, $this->colour);
	}

	public static function getSymbolForPiece(int $pieceID, string $colour) : string {
		return "&#" . (9811 + $pieceID + ($colour == ChessGame::PLAYER_WHITE ? 0 : 6)) . ";";
	}

	public static function getLetterForPiece(int $pieceID, string $colour) : string {
		$letter = match($pieceID) {
			self::KING => 'k',
			self::QUEEN => 'q',
			self::ROOK => 'r',
			self::BISHOP => 'b',
			self::KNIGHT => 'n',
			self::PAWN => 'p',
		};
		if ($colour == ChessGame::PLAYER_WHITE) {
			$letter = strtoupper($letter);
		}
		return $letter;
	}

	public static function getPieceForLetter(string $letter) : int {
		return match(strtolower($letter)) {
			'k' => self::KING,
			'q' => self::QUEEN,
			'r' => self::ROOK,
			'b' => self::BISHOP,
			'n' => self::KNIGHT,
			'p' => self::PAWN,
		};
	}
}


1			<?php declare(strict_types=1);
2
3			class ChessPiece {
4			const KING = 1;
5			const QUEEN = 2;
6			const ROOK = 3;
7			const BISHOP = 4;
8			const KNIGHT = 5;
9			const PAWN = 6;
10
11			public function __construct(
12			public int $chessGameID,
13			public int $accountID,
14			public string $colour,
15			public int $pieceID,
16			public int $x,
17			public int $y,
18			public int $pieceNo = -1) {
19			}
20
21			public function isSafeMove(array &$board, array &$hasMoved, int $toX = -1, int $toY = -1) : bool {
22			$x = $this->x;
23			$y = $this->y;
24			$moveInfo = ChessGame::movePiece($board, $hasMoved, $x, $y, $toX, $toY);
25			$safe = !ChessGame::isPlayerChecked($board, $hasMoved, $this->colour);
26			ChessGame::undoMovePiece($board, $hasMoved, $x, $y, $toX, $toY, $moveInfo);
27			return $safe;
28			}
29
30			public function isAttacking(array &$board, array &$hasMoved, bool $king, int $x = -1, int $y = -1) : bool {
31			$moves = $this->getPossibleMoves($board, $hasMoved, null, true);
32			foreach ($moves as $move) {
33			$p = $board[$move[1]][$move[0]];
34			if (($move[0] == $x && $move[1] == $y) \|\| ($king === true && $p != null && $p->pieceID == self::KING && $this->colour != $p->colour)) {
35			return true;
36			}
37			}
38			return false;
39			}
40
41			public function getPossibleMoves(array &$board, array &$hasMoved, int $forAccountID = null, bool $attackingCheck = false) : array {
42			$moves = array();
43			if ($forAccountID === null \|\| $this->accountID == $forAccountID) {
44			if ($this->pieceID == self::PAWN) {
45			$dirY = $this->colour == ChessGame::PLAYER_BLACK ? 1 : -1;
46			$moveY = $this->y + $dirY;
47			//Pawn forward movement is not attacking - so don't check it if doing an attacking check.
48			if (!$attackingCheck) {
49			if (ChessGame::isValidCoord($this->x, $moveY, $board) && $board[$moveY][$this->x] === null && $this->isSafeMove($board, $hasMoved, $this->x, $moveY)) {
50			$moves[] = array($this->x, $moveY);
51			}
52			$doubleMoveY = $moveY + $dirY;
53			if ($this->y - $dirY == 0 \|\| $this->y - $dirY * 2 == count($board)) { //Double move first move
54			if ($board[$moveY][$this->x] === null && $board[$doubleMoveY][$this->x] === null && $this->isSafeMove($board, $hasMoved, $this->x, $doubleMoveY)) {
55			$moves[] = array($this->x, $doubleMoveY);
56			}
57			}
58			}
59			for ($i = -1; $i < 2; $i += 2) {
60			$moveX = $this->x + $i;
61			if (ChessGame::isValidCoord($moveX, $moveY, $board)) {
62			if ($attackingCheck \|\|
63			((($hasMoved[ChessPiece::PAWN][0] == $moveX && $hasMoved[ChessPiece::PAWN][1] == $this->y) \|\|
64			($board[$moveY][$moveX] != null && $board[$moveY][$moveX]->colour != $this->colour))
65			&& $this->isSafeMove($board, $hasMoved, $moveX, $moveY))) {
66			$moves[] = array($moveX, $moveY);
67			}
68			}
69			}
70			} elseif ($this->pieceID == self::KING) {
71			for ($i = -1; $i < 2; $i++) {
72			for ($j = -1; $j < 2; $j++) {
73			if ($i != 0 \|\| $j != 0) {
74			$this->addMove($this->x + $i, $this->y + $j, $board, $moves, $hasMoved, $attackingCheck);
75			}
76			}
77			}
78			//Castling is not attacking - so don't check it if doing an attacking check.
79			if (!$attackingCheck && !$hasMoved[$this->colour][ChessPiece::KING] && !ChessGame::isPlayerChecked($board, $hasMoved, $this->colour)) {
80			if (!$hasMoved[$this->colour][ChessPiece::ROOK]['Queen'] &&
81			ChessGame::isValidCoord($this->x - 1, $this->y, $board) && $board[$this->y][$this->x - 1] === null &&
82			ChessGame::isValidCoord($this->x - 3, $this->y, $board) && $board[$this->y][$this->x - 3] === null &&
83			$this->isSafeMove($board, $hasMoved, $this->x - 1, $this->y)) {
84			$this->addMove($this->x - 2, $this->y, $board, $moves, $hasMoved, $attackingCheck);
85			}
86			if (!$hasMoved[$this->colour][ChessPiece::ROOK]['King'] &&
87			ChessGame::isValidCoord($this->x + 1, $this->y, $board) && $board[$this->y][$this->x + 1] === null &&
88			$this->isSafeMove($board, $hasMoved, $this->x + 1, $this->y)) {
89			$this->addMove($this->x + 2, $this->y, $board, $moves, $hasMoved, $attackingCheck);
90			}
91			}
92			} elseif ($this->pieceID == self::QUEEN) {
93			$moveX = $this->x;
94			$moveY = $this->y;
95			while ($this->addMove(--$moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Left
96			$moveX = $this->x;
97			$moveY = $this->y;
98			while ($this->addMove(++$moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Right
99			$moveX = $this->x;
100			$moveY = $this->y;
101			while ($this->addMove($moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up
102			$moveX = $this->x;
103			$moveY = $this->y;
104			while ($this->addMove($moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Down
105			$moveX = $this->x;
106			$moveY = $this->y;
107			while ($this->addMove(--$moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Left
108			$moveX = $this->x;
109			$moveY = $this->y;
110			while ($this->addMove(++$moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Right
111			$moveX = $this->x;
112			$moveY = $this->y;
113			while ($this->addMove(--$moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Down-Left
114			$moveX = $this->x;
115			$moveY = $this->y;
116			while ($this->addMove(++$moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Left
117			} elseif ($this->pieceID == self::ROOK) {
118			$moveX = $this->x;
119			$moveY = $this->y;
120			while ($this->addMove(--$moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Left
121			$moveX = $this->x;
122			$moveY = $this->y;
123			while ($this->addMove(++$moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Right
124			$moveX = $this->x;
125			$moveY = $this->y;
126			while ($this->addMove($moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up
127			$moveX = $this->x;
128			$moveY = $this->y;
129			while ($this->addMove($moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Down
130			} elseif ($this->pieceID == self::BISHOP) {
131			$moveX = $this->x;
132			$moveY = $this->y;
133			while ($this->addMove(--$moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Left
134			$moveX = $this->x;
135			$moveY = $this->y;
136			while ($this->addMove(++$moveX, --$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Right
137			$moveX = $this->x;
138			$moveY = $this->y;
139			while ($this->addMove(--$moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Down-Left
140			$moveX = $this->x;
141			$moveY = $this->y;
142			while ($this->addMove(++$moveX, ++$moveY, $board, $moves, $hasMoved, $attackingCheck) && $board[$moveY][$moveX] === null); //Up-Left
143			} elseif ($this->pieceID == self::KNIGHT) {
144			$moveX = $this->x - 1;
145			$moveY = $this->y - 2;
146			$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2up-left
147			$moveX += 2;
148			$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2up-right
149			$moveY = $this->y + 2;
150			$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2down-right
151			$moveX -= 2;
152			$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2down-left
153			$moveX = $this->x - 2;
154			$moveY = $this->y - 1;
155			$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2left-up
156			$moveY += 2;
157			$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2left-down
158			$moveX = $this->x + 2;
159			$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2right-down
160			$moveY -= 2;
161			$this->addMove($moveX, $moveY, $board, $moves, $hasMoved, $attackingCheck); //2right-up
162			}
163			}
164
165			return $moves;
166			}
167
168			private function addMove(int $toX, int $toY, array &$board, array &$moves, array &$hasMoved, bool $attackingCheck = true) : bool {
169			if (ChessGame::isValidCoord($toX, $toY, $board)) {
170			if (($board[$toY][$toX] === null \|\| $board[$toY][$toX]->colour != $this->colour)) {
171			//We can only actually move to this position if it is safe to do so, however we can pass through it looking for a safe move so we still want to return true.
172			if (($attackingCheck === true \|\| $this->isSafeMove($board, $hasMoved, $toX, $toY))) {
173			$moves[] = array($toX, $toY);
174			}
175			return true;
176			}
177			}
178			return false;
179			}
180
181			public function promote(int $pawnPromotionPieceID, array &$board) : array {
182			$takenNos = array();
183			foreach ($board as $row) {
184			foreach ($row as $piece) {
185			if ($piece != null && $piece->pieceID == $pawnPromotionPieceID && $piece->colour == $this->colour) {
186			$takenNos[$piece->pieceNo] = true;
187			}
188			}
189			}
190			$i = 0;
191			while (isset($takenNos[$i])) {
192			$i++;
193			}
194			return array('PieceID' => $pawnPromotionPieceID, 'PieceNo' => $i);
195			}
196
197			public function getPieceLetter() : string {
198			return self::getLetterForPiece($this->pieceID, $this->colour);
199			}
200
201			public function getPieceSymbol() : string {
202			return self::getSymbolForPiece($this->pieceID, $this->colour);
203			}
204
205			public static function getSymbolForPiece(int $pieceID, string $colour) : string {
206			return "&#" . (9811 + $pieceID + ($colour == ChessGame::PLAYER_WHITE ? 0 : 6)) . ";";
207			}
208
209			public static function getLetterForPiece(int $pieceID, string $colour) : string {
210			$letter = match($pieceID) {
211			self::KING => 'k',
212			self::QUEEN => 'q',
213			self::ROOK => 'r',
214			self::BISHOP => 'b',
215			self::KNIGHT => 'n',
216			self::PAWN => 'p',
217			};
218			if ($colour == ChessGame::PLAYER_WHITE) {
219			$letter = strtoupper($letter);
220			}
221			return $letter;
222			}
223
224			public static function getPieceForLetter(string $letter) : int {
225			return match(strtolower($letter)) {
226			'k' => self::KING,
227			'q' => self::QUEEN,
228			'r' => self::ROOK,
229			'b' => self::BISHOP,
230			'n' => self::KNIGHT,
231			'p' => self::PAWN,
232			};
233			}
234			}
235

smrealms / smr

Scrutinizer GitHub App not installed

Push — master ( 9c91a5...05804d )

ChessPiece::getPossibleMoves() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like