ChessPiece

Complexity

Total Complexity

106

Size/Duplication

Total Lines	229
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	1

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	getPieceSymbol()	0	2	1
A	isSafeMove()	0	7	1
A	getLetterForPiece()	0	13	2
B	isAttacking()	0	9	8
A	getPieceLetter()	0	2	1
B	promote()	0	14	7
A	addMove()	0	11	6
F	getPossibleMoves()	0	125	76
A	getSymbolForPiece()	0	2	2
A	getPieceForLetter()	0	8	1

<?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) {

It seems like you are loosely comparing $forAccountID of type integer|null against null; this is ambiguous if the integer can be zero. Consider using a strict comparison === instead.

			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 = null, 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))) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

It seems like $hasMoved can also be of type null; however, parameter $hasMoved of ChessPiece::isSafeMove() does only seem to accept array, maybe add an additional type check?

					$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,
		};
	}
}