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

public List getAttackPattern() { List attacks = new ArrayList<>(); switch (positionType) { case "RIGHT": // Only L-shaped and attacks toward LEFT // Diagonal left attacks.add(new int[]{x - 1, y - 1}); attacks.add(new int[]{x + 1, y - 1}); // L-shapes to the LEFT only attacks.add(new int[]{x - 2, y - 1}); attacks.add(new int[]{x + 2, y - 1}); attacks.add(new int[]{x - 1, y - 2}); attacks.add(new int[]{x + 1, y - 2}); // 3, 2, 1 tiles to the LEFT for (int i = 1; i <= 3; i++) { attacks.add(new int[]{x, y - i}); } break; case "LEFT": // Only L-shaped and attacks toward RIGHT // Diagonal right attacks.add(new int[]{x - 1, y + 1}); attacks.add(new int[]{x + 1, y + 1}); // L-shapes to the RIGHT only attacks.add(new int[]{x - 2, y + 1}); attacks.add(new int[]{x + 2, y + 1}); attacks.add(new int[]{x - 1, y + 2}); attacks.add(new int[]{x + 1, y + 2}); // 3, 2, 1 tiles to the RIGHT for (int i = 1; i <= 3; i++) { attacks.add(new int[]{x, y + i}); } break; case "TOP": // Attack only DOWNWARD attacks.add(new int[]{x + 1, y - 1}); attacks.add(new int[]{x + 1, y + 1}); attacks.add(new int[]{x + 2, y - 1}); attacks.add(new int[]{x + 2, y + 1}); attacks.add(new int[]{x + 1, y - 2}); attacks.add(new int[]{x + 1, y + 2}); for (int i = 1; i <= 3; i++) { attacks.add(new int[]{x + i, y}); } break; case "BOTTOM": // Attack only UPWARD attacks.add(new int[]{x - 1, y - 1}); attacks.add(new int[]{x - 1, y + 1}); attacks.add(new int[]{x - 2, y - 1}); attacks.add(new int[]{x - 2, y + 1}); attacks.add(new int[]{x - 1, y - 2}); attacks.add(new int[]{x - 1, y + 2}); for (int i = 1; i <= 3; i++) { attacks.add(new int[]{x - i, y}); } break; } return attacks; }

User prompt

if (SeaMonster.canCapture(seaRow, seaCol, targetRow, targetCol, rows, cols, board)) { // Taşı yiyoruz board[targetRow][targetCol] = null; // SeaMonster aynı yerde kalıyor, hareket etmiyor }

User prompt

import java.util.ArrayList; import java.util.List; public class SeaMonster { private int x; // row private int y; // col private String positionType; // "LEFT", "RIGHT", "TOP", "BOTTOM" public SeaMonster(int x, int y, String positionType) { this.x = x; this.y = y; this.positionType = positionType.toUpperCase(); } // Validates that the Sea Monster is in a water cell public boolean isInWater(boolean[][] boardWaterMap) { return boardWaterMap[x][y]; } // Calculates possible movement within water tiles (up to 3 tiles in straight directions) public List getPossibleMoves(boolean[][] boardWaterMap) { List moves = new ArrayList<>(); int rows = boardWaterMap.length; int cols = boardWaterMap[0].length; int[][] directions = { {-1, 0}, // up {1, 0}, // down {0, -1}, // left {0, 1} // right }; for (int[] dir : directions) { for (int step = 1; step <= 3; step++) { int nx = x + dir[0] * step; int ny = y + dir[1] * step; if (nx >= 0 && ny >= 0 && nx < rows && ny < cols && boardWaterMap[nx][ny]) { moves.add(new int[]{nx, ny}); } else { break; // Stop if not water or out of bounds } } } return moves; } // Get attack pattern based on Sea Monster's position public List getAttackPattern() { List attacks = new ArrayList<>(); switch (positionType) { case "RIGHT": attacks.add(new int[]{x - 1, y - 1}); attacks.add(new int[]{x + 1, y - 1}); attacks.add(new int[]{x - 2, y - 1}); attacks.add(new int[]{x + 2, y - 1}); attacks.add(new int[]{x - 1, y - 2}); attacks.add(new int[]{x + 1, y - 2}); for (int i = 1; i <= 3; i++) attacks.add(new int[]{x, y - i}); break; case "LEFT": attacks.add(new int[]{x - 1, y + 1}); attacks.add(new int[]{x + 1, y + 1}); attacks.add(new int[]{x - 2, y + 1}); attacks.add(new int[]{x + 2, y + 1}); attacks.add(new int[]{x - 1, y + 2}); attacks.add(new int[]{x + 1, y + 2}); for (int i = 1; i <= 3; i++) attacks.add(new int[]{x, y + i}); break; case "TOP": attacks.add(new int[]{x + 1, y - 1}); attacks.add(new int[]{x + 1, y + 1}); attacks.add(new int[]{x + 2, y - 1}); attacks.add(new int[]{x + 2, y + 1}); attacks.add(new int[]{x + 1, y - 2}); attacks.add(new int[]{x + 1, y + 2}); for (int i = 1; i <= 3; i++) attacks.add(new int[]{x + i, y}); break; case "BOTTOM": attacks.add(new int[]{x - 1, y - 1}); attacks.add(new int[]{x - 1, y + 1}); attacks.add(new int[]{x - 2, y - 1}); attacks.add(new int[]{x - 2, y + 1}); attacks.add(new int[]{x - 1, y - 2}); attacks.add(new int[]{x - 1, y + 2}); for (int i = 1; i <= 3; i++) attacks.add(new int[]{x - i, y}); break; } return attacks; } // Simulates attack on board public void attack(char[][] board) { List targets = getAttackPattern(); for (int[] pos : targets) { int tx = pos[0]; int ty = pos[1]; if (tx >= 0 && ty >= 0 && tx < board.length && ty < board[0].length) { if (Character.isUpperCase(board[tx][ty]) || Character.isLowerCase(board[tx][ty])) { board[tx][ty] = '.'; // Water after attack } } } } // Move the Sea Monster to a new location public void moveTo(int newX, int newY) { this.x = newX; this.y = newY; } // Get current position public int[] getPosition() { return new int[]{x, y}; } }

User prompt

If the pieces can capture the sea monster, they can enter the sea

User prompt

abstract class Piece { protected int row; protected int col; public Piece(int row, int col) { this.row = row; this.col = col; } public abstract String getType(); // General move method // Returns true if move is successful public boolean moveTo(int targetRow, int targetCol, Board board) { // Simple check: target square must be empty if (!board.isEmpty(targetRow, targetCol)) return false; // Here you would check piece-specific move rules // For simplicity, just move if empty this.row = targetRow; this.col = targetCol; return true; } // Capture sea monster method // The piece can move onto the sea monster's position (capture), // but after capturing, the piece's position does NOT change. public boolean captureSeaMonster(SeaMonster seaMonster, Board board) { String type = getType().toLowerCase(); if (!(type.equals("bishop") || type.equals("siegeTower") || type.equals("king"))) { return false; // Only these pieces can capture the sea monster } if (!seaMonster.isInSea()) { return false; // Sea monster must be in the sea } int seaRow = seaMonster.getRow(); int seaCol = seaMonster.getCol(); // Check if this piece can move onto the sea monster's square according to move rules if (!canMoveTo(seaRow, seaCol, board)) { return false; // Cannot move there, so cannot capture } // Remove the sea monster from the board board.removePiece(seaMonster); // IMPORTANT: The piece's position does NOT change (the piece does not actually move) // So row and col stay the same return true; // Capture successful } // Abstract method to check if piece can move to target square according to game rules protected abstract boolean canMoveTo(int targetRow, int targetCol, Board board); public int getRow() { return row; } public int getCol() { return col; } } // SeaMonster class class SeaMonster { private int row; private int col; private boolean inSea; public SeaMonster(int row, int col, boolean inSea) { this.row = row; this.col = col; this.inSea = inSea; } public int getRow() { return row; } public int getCol() { return col; } public boolean isInSea() { return inSea; } } // Board class for managing pieces class Board { private Piece[][] board; public Board(int size) { board = new Piece[size][size]; } public boolean isEmpty(int row, int col) { return board[row][col] == null; } public void removePiece(SeaMonster seaMonster) { int r = seaMonster.getRow(); int c = seaMonster.getCol(); board[r][c] = null; // You may want to update seaMonster state here as well } } // Example piece implementations: class Bishop extends Piece { public Bishop(int row, int col) { super(row, col); } @Override public String getType() { return "bishop"; } @Override protected boolean canMoveTo(int targetRow, int targetCol, Board board) { // Simple diagonal move check (no obstacle checking here) return Math.abs(targetRow - row) == Math.abs(targetCol - col); } } class SiegeTower extends Piece { public SiegeTower(int row, int col) { super(row, col); } @Override public String getType() { return "siegeTower"; } @Override protected boolean canMoveTo(int targetRow, int targetCol, Board board) { // Simple horizontal or vertical move check return (targetRow == row || targetCol == col); } } class King extends Piece { public King(int row, int col) { super(row, col); } @Override public String getType() { return "king"; } @Override protected boolean canMoveTo(int targetRow, int targetCol, Board board) { int dRow = Math.abs(targetRow - row); int dCol = Math.abs(targetCol - col); return dRow <= 1 && dCol <= 1; } }

User prompt

Make the texture of the Sea Monster's capture square orange ↪💡 Consider importing and using the following plugins: @upit/tween.v1

User prompt

// Base class for all pieces abstract class Piece { protected int row; protected int col; public Piece(int row, int col) { this.row = row; this.col = col; } public abstract String getType(); // Check if piece can capture sea monster at (seaRow, seaCol) without moving public boolean canCaptureSeaMonster(SeaMonster seaMonster) { // Only bishop, siegeTower, and king can capture String type = getType().toLowerCase(); if (!(type.equals("bishop") || type.equals("siegeTower") || type.equals("king"))) { return false; } // Piece does not move: it captures from its own position // Check if the sea monster is in range of capture from piece's position // (capture logic is simplified; customize according to your game rules) // Here, as an example, assume the piece can capture if sea monster is adjacent (including diagonals) int dRow = Math.abs(seaMonster.getRow() - this.row); int dCol = Math.abs(seaMonster.getCol() - this.col); return (dRow <= 1 && dCol <= 1); } } // SeaMonster class class SeaMonster { private int row; private int col; private boolean inSea; public SeaMonster(int row, int col, boolean inSea) { this.row = row; this.col = col; this.inSea = inSea; } public int getRow() { return row; } public int getCol() { return col; } public boolean isInSea() { return inSea; } } // Example subclasses class Bishop extends Piece { public Bishop(int row, int col) { super(row, col); } @Override public String getType() { return "bishop"; } } class SiegeTower extends Piece { public SiegeTower(int row, int col) { super(row, col); } @Override public String getType() { return "siegeTower"; } } class King extends Piece { public King(int row, int col) { super(row, col); } @Override public String getType() { return "king"; } } class OtherPiece extends Piece { public OtherPiece(int row, int col) { super(row, col); } @Override public String getType() { return "pawn"; } } // Test method public class Game { public static void main(String[] args) { SeaMonster seaMonster = new SeaMonster(4, 4, true); // sea monster at (4,4), in sea Bishop bishop = new Bishop(3, 3); SiegeTower siegeTower = new SiegeTower(5, 4); King king = new King(4, 3); OtherPiece pawn = new OtherPiece(4, 5); System.out.println("Bishop can capture: " + bishop.canCaptureSeaMonster(seaMonster)); System.out.println("SiegeTower can capture: " + siegeTower.canCaptureSeaMonster(seaMonster)); System.out.println("King can capture: " + king.canCaptureSeaMonster(seaMonster)); System.out.println("Pawn can capture: " + pawn.canCaptureSeaMonster(seaMonster)); } }

User prompt

public static boolean canCaptureSeaMonster(int attackerRow, int attackerCol, int monsterRow, int monsterCol, Piece attacker) { if (!attacker.isEnemy) return false; int dr = Math.abs(monsterRow - attackerRow); int dc = Math.abs(monsterCol - attackerCol); switch (attacker.type) { case "bishop": // Bishop attacks diagonally without moving return dr == dc; case "siegeTower": // SiegeTower attacks in straight lines without moving return (dr == 0 || dc == 0); case "king": // King attacks adjacent squares (1-square range) return dr <= 1 && dc <= 1; default: return false; // Other pieces cannot capture the SeaMonster } }

User prompt

public static boolean canCapture(int sx, int sy, int tx, int ty, Piece[][] board) { if (!isInSea(sx)) return false; if (tx < 0 || tx >= board.length || ty < 0 || ty >= board[0].length) return false; Piece target = board[tx][ty]; if (target == null || !target.isEnemy) return false; // Protected pieces: SeaMonster cannot capture these if (target.type.equals("king") || target.type.equals("rook") || target.type.equals("bishop") || // 🠔 Vanguard changed to Bishop target.type.equals("siegeTower") || isProtected(board, tx, ty)) return false; int dr = Math.abs(tx - sx); int dc = Math.abs(ty - sy); // ✅ Straight 3-square attack (horizontal or vertical) if ((dr == 0 && dc == 3) || (dc == 0 && dr == 3)) return true; // ✅ Diagonal 1-square attack if (dr == 1 && dc == 1) return true; // ❌ L-shaped and Long L attacks removed return false; }

User prompt

public static boolean canCapture(int sx, int sy, int tx, int ty, Piece[][] board) { if (!isInSea(sx)) return false; if (tx < 0 || tx >= board.length || ty < 0 || ty >= board[0].length) return false; Piece target = board[tx][ty]; if (target == null || !target.isEnemy) return false; // Korunan taşları ele geçirme engeli if (target.type.equals("king") || target.type.equals("rook") || target.type.equals("vanguard") || target.type.equals("siegeTower") || isProtected(board, tx, ty)) return false; int dr = Math.abs(tx - sx); int dc = Math.abs(ty - sy); // ✅ Sadece 3 kare düz (yatay ya da dikey) if ((dr == 0 && dc == 3) || (dc == 0 && dr == 3)) return true; // ✅ Sadece 1 kare çapraz if (dr == 1 && dc == 1) return true; // ❌ L (2+1) ve ❌ Uzun L (3+1) kaldırıldı return false; }

User prompt

class Piece { String type; // "pawn", "king", "rook", "siegeTower", "vanguard", "seaMonster", etc. boolean isEnemy; public Piece(String type, boolean isEnemy) { this.type = type; this.isEnemy = isEnemy; } } public class SeaMonster { static final int SEA_ROW_START = 6; static final int SEA_ROW_END = 7; public static boolean isInSea(int row) { return row >= SEA_ROW_START && row <= SEA_ROW_END; } public static boolean isProtected(Piece[][] board, int row, int col) { int rows = board.length; int cols = board[0].length; int[][] directions = { {-1, 0}, {1, 0}, {0, -1}, {0, 1}, // rook {-1, -1}, {-1, 1}, {1, -1}, {1, 1}, // king {-2, -1}, {-1, -2}, {-2, 1}, {-1, 2}, {1, -2}, {2, -1}, {1, 2}, {2, 1} // knight-style }; for (int[] dir : directions) { int r = row + dir[0]; int c = col + dir[1]; if (r >= 0 && r < rows && c >= 0 && c < cols && board[r][c] != null) { Piece p = board[r][c]; if (!p.isEnemy) continue; // SeaMonster only checks enemy protection if (p.type.equals("rook") && (dir[0] == 0 || dir[1] == 0)) return true; if (p.type.equals("king") && Math.abs(dir[0]) <= 1 && Math.abs(dir[1]) <= 1) return true; if (p.type.equals("vanguard") || p.type.equals("siegeTower")) return true; } } return false; } public static boolean canMoveTo(int row, int col, Piece[][] board) { if (!isInSea(row)) return false; // Cannot move to sea square threatened by a rook int[][] rookDirs = { {-1,0}, {1,0}, {0,-1}, {0,1} }; for (int[] dir : rookDirs) { for (int i = 1; i <= 3; i++) { int r = row + dir[0] * i; int c = col + dir[1] * i; if (r < 0 || r >= board.length || c < 0 || c >= board[0].length) break; Piece p = board[r][c]; if (p != null) { if (p.isEnemy && p.type.equals("rook")) { return false; } else break; } } } return true; } public static boolean canCapture(int sx, int sy, int tx, int ty, Piece[][] board) { if (!isInSea(sx)) return false; if (tx < 0 || tx >= board.length || ty < 0 || ty >= board[0].length) return false; Piece target = board[tx][ty]; if (target == null || !target.isEnemy) return false; // Cannot capture protected pieces if (target.type.equals("king") || target.type.equals("rook") || target.type.equals("vanguard") || target.type.equals("siegeTower") || isProtected(board, tx, ty)) return false; int dr = Math.abs(tx - sx); int dc = Math.abs(ty - sy); // Straight (row or col) 1-3 if ((dr == 0 && dc >= 1 && dc <= 3) || (dc == 0 && dr >= 1 && dr <= 3)) return true; // Diagonal 1 if (dr == 1 && dc == 1) return true; // L-shape if ((dr == 2 && dc == 1) || (dr == 1 && dc == 2)) return true; // Long L (3 + 1) if ((dr == 3 && dc == 1) || (dr == 1 && dc == 3)) return true; return false; } public static void attemptCapture(int sx, int sy, int tx, int ty, Piece[][] board) { if (canCapture(sx, sy, tx, ty, board)) { board[tx][ty] = null; // Captures the piece System.out.println("SeaMonster captured enemy at (" + tx + ", " + ty + ")"); } else { System.out.println("Capture not allowed."); } } public static void main(String[] args) { int rows = 8, cols = 8; Piece[][] board = new Piece[rows][cols]; // SeaMonster placed in sea area int seaX = 6, seaY = 4; // Enemy in valid position (3 right) board[6][7] = new Piece("pawn", true); // Enemy rook protecting the square (blocks capture) board[6][6] = new Piece("rook", true); // Attempt to capture attemptCapture(seaX, seaY, 6, 7, board); // Attempt to move into rook's threatened square if (canMoveTo(6, 7, board)) { System.out.println("SeaMonster can move to (6, 7)"); } else { System.out.println("SeaMonster cannot move to (6, 7) — rook threat"); } } }

User prompt

Remove the Sea Monster's ability to draw a long L

User prompt

if (SeaMonster.canCapture(seaRow, seaCol, targetRow, targetCol, rows, cols, board)) { // Taşı yiyoruz board[targetRow][targetCol] = null; // SeaMonster aynı yerde kalıyor, hareket etmiyor }

User prompt

public class SeaMonsterGame { static class Piece { boolean isEnemy; public Piece(boolean isEnemy) { this.isEnemy = isEnemy; } } static class SeaMonster { // Define sea area static final int SEA_ROW_START = 6; static final int SEA_ROW_END = 7; static final int SEA_COL_START = 0; static final int SEA_COL_END = 9; // Check if position is in the sea public static boolean isInSea(int row, int col) { return row >= SEA_ROW_START && row <= SEA_ROW_END && col >= SEA_COL_START && col <= SEA_COL_END; } // Movement: Up to 3 squares in any straight direction within the sea public static boolean canMove(int fromRow, int fromCol, int toRow, int toCol) { if (!isInSea(fromRow, fromCol) || !isInSea(toRow, toCol)) return false; int rowDiff = Math.abs(toRow - fromRow); int colDiff = Math.abs(toCol - fromCol); // Allow movement only in straight lines (no diagonals), up to 3 squares if ((rowDiff == 0 && colDiff > 0 && colDiff <= 3) || (colDiff == 0 && rowDiff > 0 && rowDiff <= 3)) { return true; } return false; } // Attack logic (SeaMonster does not move) public static boolean canCapture(int monsterRow, int monsterCol, int targetRow, int targetCol, int boardRows, int boardCols, Piece[][] board) { if (!isInSea(monsterRow, monsterCol)) return false; if (targetRow < 0 || targetRow >= boardRows || targetCol < 0 || targetCol >= boardCols) return false; Piece target = board[targetRow][targetCol]; if (target == null || !target.isEnemy) return false; int rowDiff = targetRow - monsterRow; int colDiff = targetCol - monsterCol; int absRow = Math.abs(rowDiff); int absCol = Math.abs(colDiff); // 1. Straight 3-square attacks if ((absRow == 3 && colDiff == 0) || (absCol == 3 && rowDiff == 0)) return true; // 2. 1-square diagonal if (absRow == 1 && absCol == 1) return true; // 3. Normal L-shape if ((absRow == 2 && absCol == 1) || (absRow == 1 && absCol == 2)) return true; // 4. Long L-shape (3+1) if ((absRow == 3 && absCol == 1) || (absRow == 1 && absCol == 3)) return true; return false; } } public static void main(String[] args) { int rows = 10; int cols = 10; Piece[][] board = new Piece[rows][cols]; int seaRow = 6; int seaCol = 4; // Place some enemy pieces in attackable positions board[3][4] = new Piece(true); // 3 up board[6][1] = new Piece(true); // 3 left board[7][7] = new Piece(true); // diagonal board[4][5] = new Piece(true); // L-shape board[3][5] = new Piece(true); // Long L board[9][3] = new Piece(true); // Outside attack range (won't be hit) // Test movement System.out.println("SeaMonster can move from (" + seaRow + ", " + seaCol + ") to:"); for (int r = 0; r < rows; r++) { for (int c = 0; c < cols; c++) { if (SeaMonster.canMove(seaRow, seaCol, r, c)) { System.out.println(" → (" + r + ", " + c + ")"); } } } // Test attack System.out.println("\nSeaMonster can attack from (" + seaRow + ", " + seaCol + "):"); for (int r = 0; r < rows; r++) { for (int c = 0; c < cols; c++) { if (SeaMonster.canCapture(seaRow, seaCol, r, c, rows, cols, board)) { System.out.println(" → (" + r + ", " + c + ")"); } } } } }

User prompt

Add Sea Monster, can move 3 squares left and right

User prompt

public class SeaMonsterGame { static class Piece { boolean isEnemy; public Piece(boolean isEnemy) { this.isEnemy = isEnemy; } } static class SeaMonster { // Define sea area (example: columns 0 to 9, rows 6–7) static final int SEA_COL_START = 0; static final int SEA_COL_END = 9; static final int SEA_ROW_START = 6; static final int SEA_ROW_END = 9; public static boolean isInSea(int row, int col) { return row >= SEA_ROW_START && row <= SEA_ROW_END && col >= SEA_COL_START && col <= SEA_COL_END; } // Movement: only vertical (up to 3 squares), no left/right public static boolean canMoveInSea(int fromRow, int toRow, int col) { int rowDiff = Math.abs(toRow - fromRow); return isInSea(toRow, col) && rowDiff <= 3; } // Attack logic (SeaMonster does not move) public static boolean canCapture(int monsterRow, int monsterCol, int targetRow, int targetCol, int boardRows, int boardCols, Piece[][] board) { if (!isInSea(monsterRow, monsterCol)) return false; if (targetRow < 0 || targetRow >= boardRows || targetCol < 0 || targetCol >= boardCols) return false; Piece target = board[targetRow][targetCol]; if (target == null || !target.isEnemy) return false; int rowDiff = targetRow - monsterRow; int colDiff = targetCol - monsterCol; int absRow = Math.abs(rowDiff); int absCol = Math.abs(colDiff); // 1. 3 squares straight (row or col) if ((absRow == 3 && absCol == 0) || (absCol == 3 && absRow == 0)) return true; // 2. 1-square diagonal if (absRow == 1 && absCol == 1) return true; // 3. Regular L-shape if ((absRow == 2 && absCol == 1) || (absRow == 1 && absCol == 2)) return true; // 4. Long L-shape (3 + 1) if ((absRow == 3 && absCol == 1) || (absRow == 1 && absCol == 3)) return true; return false; } } public static void main(String[] args) { int rows = 10; int cols = 10; Piece[][] board = new Piece[rows][cols]; // SeaMonster starts at (6, 4) in the sea int seaRow = 6; int seaCol = 4; // Place some enemy pieces for testing board[3][4] = new Piece(true); // vertical 3 up board[6][7] = new Piece(true); // diagonal board[4][6] = new Piece(true); // L-shape board[3][5] = new Piece(true); // long L board[9][3] = new Piece(true); // long L down board[8][4] = new Piece(true); // vertical move position // Movement test System.out.println("SeaMonster can move from (" + seaRow + ", " + seaCol + ") to:"); for (int r = 0; r < rows; r++) { if (SeaMonster.canMoveInSea(seaRow, r, seaCol)) { System.out.println(" → (" + r + ", " + seaCol + ")"); } } // Attack test System.out.println("\nSeaMonster can capture:"); for (int r = 0; r < rows; r++) { for (int c = 0; c < cols; c++) { if (SeaMonster.canCapture(seaRow, seaCol, r, c, rows, cols, board)) { System.out.println(" → (" + r + ", " + c + ")"); } } } } }

User prompt

Add Sea Monster, captures chess pieces without moving them

User prompt

Add Sea Monster, cannot eat friendly chess pieces

User prompt

Add Sea Monster, cannot eat friendly chess pieces and can never leave the sea

User prompt

Add Sea Monster, you can jump over chess pieces, whether they are friends or enemies

User prompt

The Sea Monster captures chess pieces without moving them himself.

User prompt

make 4

User prompt

Add Sea Monster moves 3 squares in the sea

User prompt

Add Sea Monster Can attack 3 lines

User prompt

public class SeaMonsterGame { static class Piece { boolean isEnemy; public Piece(boolean isEnemy) { this.isEnemy = isEnemy; } } public static class SeaMonster { static final int SEA_ROW_START = 6; static final int SEA_ROW_END = 7; public static boolean isInSea(int row) { return row >= SEA_ROW_START && row <= SEA_ROW_END; } /** * SeaMonster can attack: * - Enemy pieces only * - Jumps over all pieces * - Doesn't move * - Valid targets: * 1. Straight lines (up to 3 squares) * 2. 1-square diagonals * 3. Wide horizontal L-shapes (2 horiz + 1 vert) * 4. Special left-3 zone * 5. NEW: 3 rows then 1 column (tall L-shape) */ public static boolean canCapture(int monsterRow, int monsterCol, int targetRow, int targetCol, int boardRows, int boardCols, Piece[][] board) { if (!isInSea(monsterRow)) return false; if (targetRow < 0 || targetRow >= boardRows || targetCol < 0 || targetCol >= boardCols) return false; Piece targetPiece = board[targetRow][targetCol]; if (targetPiece == null || !targetPiece.isEnemy) return false; int rowDiff = targetRow - monsterRow; int colDiff = targetCol - monsterCol; int absRow = Math.abs(rowDiff); int absCol = Math.abs(colDiff); // 1-square diagonal if (absRow == 1 && absCol == 1) return true; // Straight lines (up to 3 squares) if ((absRow == 0 && absCol >= 1 && absCol <= 3) || (absCol == 0 && absRow >= 1 && absRow <= 3)) { return true; } // Wide L-shape: 2 horizontal + 1 vertical if (absCol == 2 && absRow == 1) return true; // Special left-3 zone if (targetCol == monsterCol - 3 && (targetRow == monsterRow || targetRow == monsterRow - 1 || targetRow == monsterRow + 1)) { return true; } // NEW: Tall L-shape (3 rows + 1 column) if (absRow == 3 && absCol == 1) return true; return false; } } public static void main(String[] args) { int rows = 10; int cols = 8; Piece[][] board = new Piece[rows][cols]; int monsterRow = 6; int monsterCol = 4; // Enemy pieces in tall L shape board[3][3] = new Piece(true); // up 3, left 1 board[3][5] = new Piece(true); // up 3, right 1 board[9][3] = new Piece(true); // down 3, left 1 board[9][5] = new Piece(true); // down 3, right 1 // Valid previous targets board[5][5] = new Piece(true); // diagonal board[6][1] = new Piece(true); // 3 left board[5][1] = new Piece(true); // 3 left + up board[7][6] = new Piece(true); // L-shape right // Friendly pieces (should NOT be captured) board[5][2] = new Piece(false); board[9][4] = new Piece(false); System.out.println("SeaMonster at (" + monsterRow + ", " + monsterCol + ") can capture:"); for (int row = 0; row < rows; row++) { for (int col = 0; col < cols; col++) { if (row == monsterRow && col == monsterCol) continue; if (SeaMonster.canCapture(monsterRow, monsterCol, row, col, rows, cols, board)) { System.out.println(" → Enemy at (" + row + ", " + col + ")"); } } } } }

===================================================================
--- original.js
+++ change.js
@@ -2027,49 +2027,8 @@
 							});
 						}
 					}
 				}
-				// 4. Long L-shape attacks (3+1)
-				var longLShapeAttacks = [{
-					dr: 3,
-					dc: 1
-				}, {
-					dr: 3,
-					dc: -1
-				}, {
-					dr: -3,
-					dc: 1
-				}, {
-					dr: -3,
-					dc: -1
-				}, {
-					dr: 1,
-					dc: 3
-				}, {
-					dr: 1,
-					dc: -3
-				}, {
-					dr: -1,
-					dc: 3
-				}, {
-					dr: -1,
-					dc: -3
-				}];
-				for (var i = 0; i < longLShapeAttacks.length; i++) {
-					var move = longLShapeAttacks[i];
-					var attackRow = self.boardRow + move.dr;
-					var attackCol = self.boardCol + move.dc;
-					if (isValidSquare(attackRow, attackCol)) {
-						var piece = getPieceAt(attackRow, attackCol);
-						if (piece && piece.pieceColor !== self.pieceColor) {
-							moves.push({
-								row: attackRow,
-								col: attackCol,
-								isSeaMonsterAttack: true // Sea monster attack, doesn't move
-							});
-						}
-					}
-				}
 				break;
 		}
 		// Filter out sea squares - pieces cannot enter the sea (except sea monster)
 		var filteredMoves = [];
Showing 101 to 125 of 516
1234567...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