Upit | Learn about creating the game Tamerlane Chess with gen AI
Play
game-community-background
game-pic

361

0

8mo

Playit
Strategic chess variant on an expanded board with powerful new pieces inspired by Timur's medieval conquests.
#StrategicChess
#MedievalWarfare
#ChessVariant
#TacticalStrategy
##chess
#tamerlanechess
#timurchess

Creation History

User prompt

class Piece { String type; String color; Piece(String type, String color) { this.type = type; this.color = color; } } public class ChessBoard { Piece[][] board = new Piece[8][8]; public static void main(String[] args) { ChessBoard board = new ChessBoard(); // Example: White has adventurousKing, Black does not board.board[7][4] = new Piece("adventurousKing", "white"); board.board[0][4] = new Piece("rook", "black"); // Threatens white king boolean whiteCanMove = board.isMoveAllowed(7, 4, 6, 4, "white"); System.out.println("White can move despite check? " + whiteCanMove); // true boolean whiteCheckmate = board.isCheckmate("white"); System.out.println("White is checkmated? " + whiteCheckmate); // false boolean blackCheckmate = board.isCheckmate("black"); System.out.println("Black is checkmated? " + blackCheckmate); // depends on board setup } // Allow moves even under check IF player has adventurousKing or shahsade boolean isMoveAllowed(int fromRow, int fromCol, int toRow, int toCol, String color) { Piece piece = board[fromRow][fromCol]; if (piece == null || !piece.color.equals(color)) return false; // Simulate the move Piece captured = boa

User prompt

class Piece { String type; String color; Piece(String type, String color) { this.type = type; this.color = color; } } public class ChessBoard { Piece[][] board = new Piece[8][8]; public static void main(String[] args) { ChessBoard board = new ChessBoard(); // Example: White has only a shahsade board.board[7][4] = new Piece("shahsade", "white"); board.board[0][4] = new Piece("rook", "black"); // Threatens the king boolean canMove = board.isMoveAllowed(7, 4, 6, 4, "white"); System.out.println("White can move despite check? " + canMove); // true boolean checkmate = board.isCheckmate("white"); System.out.println("White is checkmated? " + checkmate); // false } // Allow the move even if in check if player has shahsade or adventurousKing boolean isMoveAllowed(int fromRow, int fromCol, int toRow, int toCol, String color) { Piece piece = board[fromRow][fromCol]; if (piece == null || !piece.color.equals(color)) return false; // Simulate the move Piece captured = board[toRow][toCol]; board[toRow][toCol] = piece; board[fromRow][fromCol] = null; boolean inCheck = isKingInCheck(color); boolean hasPrivilege = hasAdventurousKing(color) || hasShahsade(color); // Undo the move board[fromRow][fromCol] = piece; board[toRow][toCol] = captured; // If the player has adventurousKing or shahsade, ignore check if (hasPrivilege) return true; // If not, disallow moving into check return !inCheck; } // Checkmate ignored if player has adventurousKing or shahsade boolean isCheckmate(String color) { if (hasAdventurousKing(color) || hasShahsade(color)) { System.out.println(color + " has adventurousKing or shahsade — checkmate ignored."); return false; } return isKingInCheck(color) && !hasAnyLegalMove(color); } // Very simple check detection (rook threatening in the same column) boolean isKingInCheck(String color) { int kingRow = -1, kingCol = -1; for (int r = 0; r < 8; r++) { for (int c = 0; c < 8; c++) { Piece p = board[r][c]; if (p != null && p.color.equals(color) && (p.type.equals("king") || p.type.equals("adventurousKing"))) { kingRow = r; kingCol = c; } } } if (kingRow == -1) return false; // Check if any enemy rook is in the same column for (int r = 0; r < 8; r++) { Piece threat = board[r][kingCol]; if (threat != null && !threat.color.equals(color) && threat.type.equals("rook")) { return true; } } return false; } // Stub method — assumes the player has legal moves boolean hasAnyLegalMove(String color) { return true; } // Check if player has adventurousKing boolean hasAdventurousKing(String color) { for (Piece[] row : board) { for (Piece p : row) { if (p != null && p.color.equals(color) && p.type.equals("adventurousKing")) { return true; } } } return false; } // Check if player has shahsade boolean hasShahsade(String color) { for (Piece[] row : board) { for (Piece p : row) { if (p != null && p.color.equals(color) && p.type.equals("shahsade")) { return true; } } } return false; } }

User prompt

class Piece { String type; String color; Piece(String type, String color) { this.type = type; this.color = color; } } public class ChessBoard { Piece[][] board = new Piece[8][8]; public static void main(String[] args) { ChessBoard board = new ChessBoard(); // Example setup: White has only an adventurousKing board.board[7][4] = new Piece("adventurousKing", "white"); board.board[0][4] = new Piece("rook", "black"); // Threatens the king boolean canMove = board.isMoveAllowed(7, 4, 6, 4, "white"); System.out.println("White can move despite check? " + canMove); // true boolean checkmate = board.isCheckmate("white"); System.out.println("White is checkmated? " + checkmate); // false } // Allow the move even if in check if the player has adventurousKing boolean isMoveAllowed(int fromRow, int fromCol, int toRow, int toCol, String color) { Piece piece = board[fromRow][fromCol]; if (piece == null || !piece.color.equals(color)) return false; // Simulate the move Piece captured = board[toRow][toCol]; board[toRow][toCol] = piece; board[fromRow][fromCol] = null; boolean inCheck = isKingInCheck(color); boolean hasAdvKing = hasAdventurousKing(color); // Undo the move board[fromRow][fromCol] = piece; board[toRow][toCol] = captured; // If the player has adventurousKing, ignore check rules if (hasAdvKing) return true; // For regular kings: disallow move if it leaves player in check return !inCheck; } // Ignore checkmate if player has adventurousKing boolean isCheckmate(String color) { if (hasAdventurousKing(color)) { System.out.println(color + " has adventurousKing — checkmate ignored."); return false; } return isKingInCheck(color) && !hasAnyLegalMove(color); } // Very simple check detection (only vertical threats by rooks) boolean isKingInCheck(String color) { int kingRow = -1, kingCol = -1; for (int r = 0; r < 8; r++) { for (int c = 0; c < 8; c++) { Piece p = board[r][c]; if (p != null && p.color.equals(color) && (p.type.equals("king") || p.type.equals("adventurousKing"))) { kingRow = r; kingCol = c; } } } if (kingRow == -1) return false; // Check if any enemy rook is in the same column for (int r = 0; r < 8; r++) { Piece threat = board[r][kingCol]; if (threat != null && !threat.color.equals(color) && threat.type.equals("rook")) { return true; } } return false; } // Placeholder for move generation logic boolean hasAnyLegalMove(String color) { return true; // In a real game, this would test all pieces } // Check if player has adventurousKing boolean hasAdventurousKing(String color) { for (Piece[] row : board) { for (Piece p : row) { if (p != null && p.color.equals(color) && p.type.equals("adventurousKing")) { return true; } } } return false; } }

User prompt

boolean isCheckmate(String color) { // If player has adventurousKing, ignore checkmate if (hasAdventurousKing(color)) { System.out.println("Checkmate ignored due to adventurousKing."); return false; } // Regular checkmate logic here // Example placeholder: boolean inCheck = isKingInCheck(color); boolean hasNoLegalMoves = !hasAnyLegalMove(color); return inCheck && hasNoLegalMoves; }

User prompt

class Piece { String type; String color; Piece(String type, String color) { this.type = type; this.color = color; } boolean is(String t) { return type.equals(t); } } class ChessBoard { Piece[][] board = new Piece[8][8]; // Main method to check move legality boolean isMoveAllowed(int fromRow, int fromCol, int toRow, int toCol, String color) { Piece p = board[fromRow][fromCol]; if (p == null || !p.color.equals(color)) return false; // Simulate move Piece captured = board[toRow][toCol]; board[toRow][toCol] = p; board[fromRow][fromCol] = null; // Convert adventurousKing to king if required convertAdventurousKingIfNeeded(color); boolean inCheck = isKingInCheck(color); boolean hasAdventurous = hasAdventurousKing(color); boolean isAdventurousActive = hasAdventurous && !hasRealKing(color); // Undo simulated move board[fromRow][fromCol] = p; board[toRow][toCol] = captured; // If it's a real king or converted adventurousKing, enforce check rules if (!isAdventurousActive && inCheck) return false; return true; } // Check if a real king is present boolean hasRealKing(String color) { for (Piece[] row : board) { for (Piece p : row) { if (p != null && p.color.equals(color) && p.type.equals("king")) return true; } } return false; } // Check if player has adventurousKing boolean hasAdventurousKing(String color) { for (Piece[] row : board) { for (Piece p : row) { if (p != null && p.color.equals(color) && p.type.equals("adventurousKing")) return true; } } return false; } // Check if shahsade exists boolean hasShahsade(String color) { for (Piece[] row : board) { for (Piece p : row) { if (p != null && p.color.equals(color) && p.type.equals("shahsade")) return true; } } return false; } // Convert adventurousKing to king if both king and shahsade are missing void convertAdventurousKingIfNeeded(String color) { if (hasRealKing(color) || hasShahsade(color)) return; for (int r = 0; r < 8; r++) { for (int c = 0; c < 8; c++) { Piece p = board[r][c]; if (p != null && p.color.equals(color) && p.type.equals("adventurousKing")) { p.type = "king"; System.out.println("AdventurousKing converted to KING at (" + r + "," + c + ")"); return; } } } } // Placeholder: Implement your own check detection logic here boolean isKingInCheck(String color) { // Check detection logic... return false; // Replace this with real check calculation } }

User prompt

Please fix the bug: 'Uncaught ReferenceError: whiteAdventurousKing is not defined' in or related to this line: 'if (whiteAdventurousKing) {' Line Number: 3096

User prompt

If the player has the adventurous king, the obligation to protect the king is removed when the king is checked

User prompt

Remove ✅ adventurous king victory condition allowing defeat of shah without checkmate

User prompt

If the player who brought the adventurousKing into play is in checkmate when the adventurousKing is promoted, the game is over

User prompt

When the player who brought the adventurousKing into play is promoted, the shah returns to its old rules

User prompt

If the player who brings the adventurousKing into play loses the shah or has no shahsade, the game does not end; the shahsade is promoted to a new shah

User prompt

The player who brings the adventurousKing into play cannot check the king. If the king is checked, the player is not obliged to prevent the check

User prompt

The player who brings the adventurousKing into play can now defeat the Shah without checkmating him

User prompt

import java.util.*; class Piece { String type, color; boolean hasTeleported = false; Piece(String type, String color) { this.type = type; this.color = color; } } class ChessBoard { Piece[][] board = new Piece[8][8]; // List of types the pawn_of_pawns cannot threaten static final Set EXCLUDED_TYPES = Set.of( "camelPawn", "giraffePawn", "guardsPawn", "kingsPawn", "knightPawn", "lionsPawn", "ministersPawn", "pawnOfTheBull", "pawnOfTheElephant", "pawnOfTheLeader", "pawn", "pawnOfTheWarMachine", "viziersPawn", "king" ); // Try teleporting pawn_of_pawns if conditions are met void tryTeleportPawnOfPawns(String color) { for (int r = 0; r < 8; r++) { for (int c = 0; c < 8; c++) { Piece p = board[r][c]; if (p != null && p.type.equals("pawn_of_pawns") && p.color.equals(color) && !p.hasTeleported) { for (int tr = 0; tr < 8; tr++) { for (int tc = 0; tc < 8; tc++) { if (board[tr][tc] != null) continue; // Simulate move to (tr, tc) int threats = countValidThreats(tr, tc, color); boolean blocksImmobilizedEnemy = threatensBlockedEnemy(tr, tc, color); if (threats >= 2 || blocksImmobilizedEnemy) { board[tr][tc] = p; board[r][c] = null; p.hasTeleported = true; System.out.println("Pawn of Pawns TELEPORTED to (" + tr + "," + tc + ")"); return; } } } } } } } // Count threatened enemy pieces (excluding the listed types) int countValidThreats(int row, int col, String color) { int count = 0; int[][] dirs = { {-1, -1}, {-1, 1}, {1, -1}, {1, 1} }; // Diagonals for (int[] d : dirs) { int r = row + d[0]; int c = col + d[1]; if (isInsideBoard(r, c)) { Piece enemy = board[r][c]; if (enemy != null && !enemy.color.equals(color) && !EXCLUDED_TYPES.contains(enemy.type)) { count++; } } } return count; } // Check if a threatened enemy piece has no legal moves (very simplified) boolean threatensBlockedEnemy(int row, int col, String color) { int[][] dirs = { {-1, -1}, {-1, 1}, {1, -1}, {1, 1} }; // Diagonals for (int[] d : dirs) { int r = row + d[0]; int c = col + d[1]; if (isInsideBoard(r, c)) { Piece enemy = board[r][c]; if (enemy != null && !enemy.color.equals(color) && !EXCLUDED_TYPES.contains(enemy.type)) { if (!hasLegalMoves(enemy, r, c)) { return true; } } } } return false; } // Simplified placeholder for checking if a piece has any legal moves boolean hasLegalMoves(Piece piece, int row, int col) { // This should be replaced by your game's actual move logic // For now, assume it has no legal moves return false; } boolean isInsideBoard(int r, int c) { return r >= 0 && r < 8 && c >= 0 && c < 8; } }

User prompt

class Piece { String type, color; boolean justPromoted; Piece(String type, String color) { this.type = type; this.color = color; this.justPromoted = false; } } class ChessBoard { Piece[][] board = new Piece[8][8]; void teleportPromotedQueen(String color) { for (int r1 = 0; r1 < 8; r1++) { for (int c1 = 0; c1 < 8; c1++) { Piece p = board[r1][c1]; if (p != null && p.justPromoted && p.type.equals("queen") && p.color.equals(color)) { for (int r2 = 0; r2 < 8; r2++) { for (int c2 = 0; c2 < 8; c2++) { if (board[r2][c2] == null && countDiagonalThreats(r2, c2, color) == 2) { board[r2][c2] = p; board[r1][c1] = null; p.justPromoted = false; System.out.println("Queen teleported to (" + r2 + "," + c2 + ")"); return; } } } } } } } int countDiagonalThreats(int row, int col, String color) { int[][] dirs = {{-1, -1}, {-1, 1}, {1, -1}, {1, 1}}; int threats = 0; for (int[] d : dirs) { int r = row + d[0], c = col + d[1]; while (r >= 0 && r < 8 && c >= 0 && c < 8) { Piece enemy = board[r][c]; if (enemy != null) { if (!enemy.color.equals(color) && !enemy.type.equals("pawn")) threats++; break; } r += d[0]; c += d[1]; } } return threats; } }

User prompt

class Piece { String type; // "pawn", "queen", etc. String color; // "white" or "black" boolean justPromoted; // true only immediately after promotion public Piece(String type, String color) { this.type = type; this.color = color; this.justPromoted = false; } } class ChessBoard { Piece[][] board = new Piece[8][8]; public void teleportPromotedPawnIfDoubleThreat(String color) { // Search for promoted pawn (now a queen, for example) for (int row = 0; row < 8; row++) { for (int col = 0; col < 8; col++) { Piece piece = board[row][col]; if (piece != null && piece.color.equals(color) && piece.justPromoted && piece.type.equals("queen")) { // Scan the board for a square where the queen could attack two opponent pieces diagonally for (int r = 0; r < 8; r++) { for (int c = 0; c < 8; c++) { if (isValidQueenDoubleThreat(r, c, color)) { board[r][c] = piece; // Move the piece board[row][col] = null; // Clear original square piece.justPromoted = false; // Only once allowed System.out.println("Teleported promoted pawn to (" + r + "," + c + ")"); return; } } } } } } } // Check if placing a queen at (row, col) would threaten exactly 2 enemy pieces diagonally private boolean isValidQueenDoubleThreat(int row, int col, String color) { if (board[row][col] != null) return false; int threats = 0; int[][] diagonals = { {-1, -1}, {-1, 1}, {1, -1}, {1, 1} }; for (int[] dir : diagonals) { int r = row + dir[0]; int c = col + dir[1]; while (r >= 0 && r < 8 && c >= 0 && c < 8) { Piece p = board[r][c]; if (p != null) { if (!p.color.equals(color)) { threats++; } break; // only first piece in that diagonal } r += dir[0]; c += dir[1]; } } return threats == 2; } }

User prompt

class Piece { String type, color; boolean justPromoted; Piece(String type, String color) { this.type = type; this.color = color; this.justPromoted = false; } } class ChessBoard { Piece[][] board = new Piece[8][8]; void teleportPromotedPawn(String color) { for (int r1 = 0; r1 < 8; r1++) { for (int c1 = 0; c1 < 8; c1++) { Piece p = board[r1][c1]; if (p != null && p.type.equals("pawn") && p.color.equals(color) && p.justPromoted) { for (int r2 = 0; r2 < 8; r2++) { for (int c2 = 0; c2 < 8; c2++) { if (board[r2][c2] == null && countDiagonalThreats(r2, c2, color) == 2) { board[r2][c2] = p; board[r1][c1] = null; p.justPromoted = false; System.out.println("Promoted pawn teleported to (" + r2 + "," + c2 + ")"); return; } } } } } } } int countDiagonalThreats(int row, int col, String color) { int[][] directions = { {-1, -1}, {-1, 1}, {1, -1}, {1, 1} }; int threats = 0; for (int[] d : directions) { int r = row + d[0], c = col + d[1]; while (r >= 0 && r < 8 && c >= 0 && c < 8) { Piece target = board[r][c]; if (target != null) { if (!target.color.equals(color) && !target.type.equals("pawn")) { threats++; } break; // Only the first piece in the diagonal matters } r += d[0]; c += d[1]; } } return threats; } }

User prompt

Delete Pawn's Pawn's freeze feature

User prompt

Add to Pawn's Pawn = Add the freezing feature to Pawn's pawn

User prompt

Add to Pawn's Pawn = It must move at least 1 square to be promoted.

User prompt

Add to pawn = Special ability = Promotion: When this piece reaches the opponent's last square, it becomes a Pawn of Pawns. Change the texture of the piece according to the piece it transforms into

User prompt

Add to pawn = Special ability = Promotion: When this piece reaches the opponent's last square, it becomes a pawn. Change the texture of the piece according to the piece it transforms into.

User prompt

New piece = Pawn's Pawn Movements = Same as pawn Position = Not present at the start of the game Special ability = If the pawn of pawns is on the opponent's last square, the opponent's pieces cannot be captured or moved until it can threaten two enemy pieces at the same time. It must move to the square it can threaten, and this move does not consume the player's turn and occurs automatically. There must be no pieces on the square it moves to, and it can only perform this move once. The pieces must be the specified pieces. (camelPawn, giraffePawn, guardsPawn, kingsPawn, knightPawn, lionsPawn, ministersPawn, pawnOfTheBull, pawnOfTheElephant, pawnOfTheLeader, pawn, pawnOfTheWarMachine, viziersPawn, pawn, king), the Pawn of Pawns transforms into an Adventurer King when promoted

User prompt

adventurousKing add texture file

User prompt

New Piece = Adventurous King Position = Cannot be found at the start of the game Special Ability = Same as the Prince Movements = Like the King, and can jump 2 squares

===================================================================
--- original.js
+++ change.js
@@ -13,9 +13,9 @@
 	self.boardRow = row;
 	self.boardCol = col;
 	self.hasMoved = false;
 	self.isPromoted = false; // Track permanent promotion status for vizier
-	self.justPromoted = false; // Track if piece was just promoted this turn
+	self.hasTeleported = false; // Track if pawn's pawn has used teleportation
 	var pieceGraphics = self.attachAsset(type, {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
@@ -2696,9 +2696,8 @@
 		if (targetRow === opponentLastRow) {
 			// Transform into promoted vizier
 			piece.pieceType = 'queen';
 			piece.isPromoted = true;
-			piece.justPromoted = true; // Mark as just promoted for teleportation
 			// Change texture to queen
 			piece.removeChildAt(0); // Remove old texture
 			var queenGraphics = piece.attachAsset('queen', {
 				anchorX: 0.5,
@@ -2910,10 +2909,8 @@
 		}
 	}
 	currentPlayer = 1 - currentPlayer;
 	selectPiece(null);
-	// Check for promoted queen teleportation
-	teleportPromotedQueen(1 - currentPlayer); // Check for the player who just moved
 	// Check for victory conditions
 	checkGameEnd();
 }
 function isSquareAttacked(row, col, byColor) {
@@ -3015,63 +3012,8 @@
 		return true; // Bu hareket yan L hareketidir
 	}
 	return false;
 }
-function countDiagonalThreats(row, col, color) {
-	var dirs = [{
-		dr: -1,
-		dc: -1
-	}, {
-		dr: -1,
-		dc: 1
-	}, {
-		dr: 1,
-		dc: -1
-	}, {
-		dr: 1,
-		dc: 1
-	}];
-	var threats = 0;
-	for (var d = 0; d < dirs.length; d++) {
-		var dir = dirs[d];
-		var r = row + dir.dr;
-		var c = col + dir.dc;
-		while (r >= 0 && r < BOARD_HEIGHT && c >= 0 && c < BOARD_WIDTH) {
-			var enemy = getPieceAt(r, c);
-			if (enemy) {
-				if (enemy.pieceColor !== color && enemy.pieceType !== 'pawn') {
-					threats++;
-				}
-				break;
-			}
-			r += dir.dr;
-			c += dir.dc;
-		}
-	}
-	return threats;
-}
-function teleportPromotedQueen(color) {
-	for (var r1 = 0; r1 < BOARD_HEIGHT; r1++) {
-		for (var c1 = 0; c1 < BOARD_WIDTH; c1++) {
-			var p = getPieceAt(r1, c1);
-			if (p && p.justPromoted && p.pieceType === 'queen' && p.pieceColor === color) {
-				for (var r2 = 0; r2 < BOARD_HEIGHT; r2++) {
-					for (var c2 = 0; c2 < BOARD_WIDTH; c2++) {
-						if (!getPieceAt(r2, c2) && countDiagonalThreats(r2, c2, color) === 2) {
-							// Teleport the queen
-							p.moveTo(r2, c2);
-							p.justPromoted = false;
-							console.log("Queen teleported to (" + r2 + "," + c2 + ")");
-							// Visual feedback for teleportation
-							LK.effects.flashObject(p, 0x00FFFF, 1000); // Flash cyan
-							return;
-						}
-					}
-				}
-			}
-		}
-	}
-}
 function checkGameEnd() {
 	var whiteKing = findKing(0);
 	var blackKing = findKing(1);
 	// Check if a player who brought shahsade into play loses their king
@@ -3236,10 +3178,87 @@
 game.update = function () {
 	if (!gameStarted) {
 		initializeGame();
 	}
+	// Try teleporting pawn of pawns for current player
+	tryTeleportPawnOfPawns(currentPlayer);
 	var playerText = currentPlayer === 0 ? 'White to move' : 'Black to move';
 	if (isInCheck(currentPlayer)) {
 		playerText += ' (Check!)';
 	}
 	turnText.setText(playerText);
-};
\ No newline at end of file
+};
+// List of types the pawn_of_pawns cannot threaten
+var EXCLUDED_TYPES = ['camelPawn', 'giraffePawn', 'guardsPawn', 'kingsPawn', 'knightPawn', 'lionsPawn', 'ministersPawn', 'pawnOfTheBull', 'pawnOfTheElephant', 'pawnOfTheLeader', 'pawn', 'pawnOfTheWarMachine', 'viziersPawn', 'king'];
+function tryTeleportPawnOfPawns(color) {
+	for (var r = 0; r < BOARD_HEIGHT; r++) {
+		for (var c = 0; c < BOARD_WIDTH; c++) {
+			var p = getPieceAt(r, c);
+			if (p && p.pieceType === 'pawnsPawn' && p.pieceColor === color && !p.hasTeleported) {
+				for (var tr = 0; tr < BOARD_HEIGHT; tr++) {
+					for (var tc = 0; tc < BOARD_WIDTH; tc++) {
+						if (getPieceAt(tr, tc)) continue; // Square must be empty
+						var threats = countValidThreats(tr, tc, color);
+						var blocksImmobilizedEnemy = threatensBlockedEnemy(tr, tc, color);
+						if (threats >= 2 || blocksImmobilizedEnemy) {
+							// Teleport the pawn of pawns
+							p.boardRow = tr;
+							p.boardCol = tc;
+							p.hasTeleported = true;
+							var pos = getBoardPosition(tr, tc);
+							tween(p, {
+								x: pos.x,
+								y: pos.y
+							}, {
+								duration: 300
+							});
+							console.log('Pawn of Pawns TELEPORTED to (' + tr + ',' + tc + ')');
+							return;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+function countValidThreats(row, col, color) {
+	var count = 0;
+	var dirs = [[-1, -1], [-1, 1], [1, -1], [1, 1]]; // Diagonals
+	for (var d = 0; d < dirs.length; d++) {
+		var dir = dirs[d];
+		var r = row + dir[0];
+		var c = col + dir[1];
+		if (isValidSquare(r, c)) {
+			var enemy = getPieceAt(r, c);
+			if (enemy && enemy.pieceColor !== color && EXCLUDED_TYPES.indexOf(enemy.pieceType) === -1) {
+				count++;
+			}
+		}
+	}
+	return count;
+}
+function threatensBlockedEnemy(row, col, color) {
+	var dirs = [[-1, -1], [-1, 1], [1, -1], [1, 1]]; // Diagonals
+	for (var d = 0; d < dirs.length; d++) {
+		var dir = dirs[d];
+		var r = row + dir[0];
+		var c = col + dir[1];
+		if (isValidSquare(r, c)) {
+			var enemy = getPieceAt(r, c);
+			if (enemy && enemy.pieceColor !== color && EXCLUDED_TYPES.indexOf(enemy.pieceType) === -1) {
+				if (!hasLegalMovesForPiece(enemy, r, c)) {
+					return true;
+				}
+			}
+		}
+	}
+	return false;
+}
+function hasLegalMovesForPiece(piece, row, col) {
+	var moves = piece.getRawMoves();
+	for (var i = 0; i < moves.length; i++) {
+		if (isValidMoveConsideringCheck(piece, moves[i].row, moves[i].col)) {
+			return true;
+		}
+	}
+	return false;
+}
\ No newline at end of file
Showing 201 to 225 of 516
1...7891011...21

Images

Remove the chessboard in the middle and paint the center completely black Remove the chessboard in the middle and paint it completely white. Make background timurid flag

Sounds & Music

🎵

capture

Sound effect

🎵

move

Sound effect

🎵

castle

Sound effect

🎵

promotion

Sound effect

🎵

checkmate

Sound effect

Used plugins

@upit/tween

Most played remixes

Tamerlane Chess
Home
Discover
Play
Profile