[V0_FILE]typescriptreact:file="lib/firebase.ts" isMerged="true" import { initializeApp } from "firebase/app" import { getFirestore } from "firebase/firestore" const firebaseConfig = { apiKey: "AIzaSyBqWWgqJpKOjXXXXXXXXXXXXXXXXXXXXXX", authDomain: "your-project.firebaseapp.com", projectId: "your-project-id", storageBucket: "your-project.appspot.com", messagingSenderId: "123456789", appId: "1:123456789:web:abcdefghijklmnop", } const app = initializeApp(firebaseConfig) export const db = getFirestore(app) [V0_FILE]typescriptreact:file="components/chess-piece.tsx" isMerged="true" import type { ChessPiece } from "@/lib/types" interface ChessPieceProps { piece: ChessPiece size?: number } const pieceSymbols = { white: { king: "♔", queen: "♕", rook: "♖", bishop: "♗", knight: "♘", pawn: "♙", }, black: { king: "♚", queen: "♛", rook: "♜", bishop: "♝", knight: "♞", pawn: "♟", }, } export default function ChessPieceComponent({ piece, size = 40 }: ChessPieceProps) { const symbol = pieceSymbols[piece.color][piece.type] return ( {symbol} ) } [V0_FILE]typescriptreact:file="app/play/loading.tsx" isFixed="true" isMerged="true" export default function Loading() { return null } [V0_FILE]png:file="public/images/ocean-breeze.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/zzzzzzzzz.PNG-BFUMHkk7VnFYk9kSfbhaYrzasz5IGz.png" isMerged="true" [V0_FILE]png:file="public/images/black-silver.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/zzzzzzzzzzzzzzzzzzzzzzzzzzzzz.PNG-sPaLsxeT5Jv8TTdz7Hs2d9W99O4uLz.png" isMerged="true" [V0_FILE]png:file="public/images/forest-canopy.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/zzzzzzzzzzzzzzzz.PNG-e9jN4TgXwiyHk5jXOEKDCN5juco4j3.png" isMerged="true" [V0_FILE]png:file="public/images/beige-brown.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/zzzzzzzzzzz.PNG-jgokhPG7kirMlE0KRY0Pt8MAbsxa6j.png" isMerged="true" [V0_FILE]typescriptreact:file="lib/types.ts" isEdit="true" isQuickEdit="true" isMerged="true" export type PieceType = "pawn" | "rook" | "knight" | "bishop" | "queen" | "king" export type PieceColor = "white" | "black" export interface ChessPiece { type: PieceType color: PieceColor } export interface Position { row: number col: number } export interface Move { from: Position to: Position piece: ChessPiece capturedPiece?: ChessPiece isCheck?: boolean isCheckmate?: boolean notation?: string } export interface GameState { board: (ChessPiece | null)[][] currentPlayer: PieceColor moves: Move[] isCheck: boolean isCheckmate: boolean whiteTime: number blackTime: number gameMode: "pvp" | "bot" | "online" gameId?: string } export type Theme = "ocean-breeze" | "black-silver" | "forest-canopy" | "beige-brown" export interface ThemeColors { lightSquare: string darkSquare: string highlight: string check: string } [V0_FILE]typescriptreact:file="components/theme-switcher.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { useTheme } from "@/lib/theme-context" import type { Theme } from "@/lib/types" export default function ThemeSwitcher() { const { theme, setTheme } = useTheme() const themes: { value: Theme; label: string }[] = [ { value: "ocean-breeze", label: "Ocean Breeze" }, { value: "black-silver", label: "Black & Silver" }, { value: "forest-canopy", label: "Forest Canopy" }, { value: "beige-brown", label: "Beige & Brown" }, ] return (

) } [V0_FILE]typescriptreact:file="components/game-timer.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { useEffect, useState } from "react" interface GameTimerProps { time: number isActive: boolean onTimeUp: () => void label: string } export default function GameTimer({ time, isActive, onTimeUp, label }: GameTimerProps) { const [currentTime, setCurrentTime] = useState(time) useEffect(() => { setCurrentTime(time) }, [time]) useEffect(() => { if (!isActive || currentTime <= 0) return const interval = setInterval(() => { setCurrentTime((prev) => { if (prev <= 1000) { onTimeUp() return 0 } return prev - 1000 }) }, 1000) return () => clearInterval(interval) }, [isActive, currentTime, onTimeUp]) const formatTime = (ms: number) => { const minutes = Math.floor(ms / 60000) const seconds = Math.floor((ms % 60000) / 1000) return `${minutes}:${seconds.toString().padStart(2, "0")}` } const isLowTime = currentTime < 60000 // Less than 1 minute return (

{label}

{formatTime(currentTime)}

) } [V0_FILE]typescriptreact:file="app/layout.tsx" isEdit="true" isQuickEdit="true" isMerged="true" import type React from "react" import type { Metadata } from "next" import { Abril_Fatface, Inter } from "next/font/google" import "./globals.css" import { ThemeProvider } from "@/lib/theme-context" const abrilFatface = Abril_Fatface({ weight: "400", subsets: ["latin"], variable: "--font-abril", }) const inter = Inter({ subsets: ["latin"] }) export const metadata: Metadata = { title: "𝔹𝕆𝔸ℝ𝔻𝕨𝕚𝕤𝕖 - Chess Game", description: "A modern chess game with AI and online multiplayer", } export default function RootLayout({ children, }: { children: React.ReactNode }) { return ( {children}

V.R.S.

) } [V0_FILE]jpeg:file="public/images/chess-wallpaper.jpeg" url="https://sjc.microlink.io/4K4nou6Sry12rreuqxmpg0WaX4iNCfnfNAaiM0rD918w6esz_8ZmPLQI7P_8lRSVzV6vmS_UKb5I7cLQBnSHPw.jpeg" isMerged="true" [V0_FILE]typescriptreact:file="app/online/page.tsx" isEdit="true" isMerged="true" "use client" import { useState } from "react" import { useRouter } from "next/navigation" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card" export default function OnlineSetupPage() { const [gameId, setGameId] = useState("") const [isCreating, setIsCreating] = useState(false) const router = useRouter() const createGame = async () => { setIsCreating(true) // Generate a random game ID const newGameId = Math.random().toString(36).substring(2, 8).toUpperCase() // In a real implementation, you would create the game in Firebase here setTimeout(() => { router.push(`/play?mode=online&gameId=${newGameId}&color=white`) }, 1000) } const joinGame = () => { if (gameId.trim()) { router.push(`/play?mode=online&gameId=${gameId.trim()}&color=black`) } } return (

𝔹𝕆𝔸ℝ𝔻𝕨𝕚𝕤𝕖 - Online Multiplayer

setGameId(e.target.value.toUpperCase())} className="text-center text-lg" maxLength={6} />

) } [V0_FILE]typescriptreact:file="app/page.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { useEffect, useState } from "react" import { useRouter } from "next/navigation" export default function LoadingScreen() { const [progress, setProgress] = useState(0) const router = useRouter() useEffect(() => { const interval = setInterval(() => { setProgress((prev) => { if (prev >= 100) { clearInterval(interval) setTimeout(() => router.push("/modes"), 500) return 100 } return prev + 2 }) }, 100) return () => clearInterval(interval) }, [router]) return (

{/* Game name at the top */}

𝔹𝕆𝔸ℝ𝔻𝕨𝕚𝕤𝕖

{/* Spacer to push loading bar to bottom */}

{/* Loading bar at the bottom */}

Loading... {progress}%

) } [V0_FILE]css:file="app/globals.css" isEdit="true" isMerged="true" @tailwind base; @tailwind components; @tailwind utilities; :root { --light-square: #c0c0c0; --dark-square: #2c2c2c; --highlight: #ffd700; --check: #ff4444; } .chess-wallpaper-bg { background-image: url("/images/chess-wallpaper.jpeg"); background-size: cover; background-position: center; background-repeat: no-repeat; position: relative; } .chess-wallpaper-bg::before { content: ""; position: absolute; top: 0; left: 0; right: 0; bottom: 0; background: rgba(0, 0, 0, 0.4); z-index: 1; } .chess-wallpaper-bg > * { position: relative; z-index: 2; } .loading-progress { background: linear-gradient(90deg, #c0c0c0 0%, #a8a8a8 100%); } .theme-ocean-breeze { background: linear-gradient(135deg, #e0f7fa 0%, #b2ebf2 100%); } .theme-black-silver { background: linear-gradient(135deg, #1a1a1a 0%, #2d2d2d 100%); } .theme-forest-canopy { background: linear-gradient(135deg, #e8f5e8 0%, #c8e6c9 100%); } .theme-beige-brown { background: linear-gradient(135deg, #fdf6e3 0%, #f5e6d3 100%); } .current-player-indicator { background: rgba(255, 255, 255, 0.9); backdrop-filter: blur(10px); border: 1px solid rgba(255, 255, 255, 0.2); border-radius: 12px; padding: 12px 24px; font-weight: 600; color: #374151; box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1); } @layer base { * { @apply border-border; } body { @apply bg-background text-foreground; } } [V0_FILE]typescriptreact:file="lib/chess-logic.ts" isEdit="true" isMerged="true" import type { ChessPiece, Position, Move, GameState, PieceType, PieceColor } from "./types" export function createInitialBoard(): (ChessPiece | null)[][] { const board: (ChessPiece | null)[][] = Array(8) .fill(null) .map(() => Array(8).fill(null)) // Place pawns for (let col = 0; col < 8; col++) { board[1][col] = { type: "pawn", color: "black" } board[6][col] = { type: "pawn", color: "white" } } // Place other pieces const pieceOrder: PieceType[] = ["rook", "knight", "bishop", "queen", "king", "bishop", "knight", "rook"] for (let col = 0; col < 8; col++) { board[0][col] = { type: pieceOrder[col], color: "black" } board[7][col] = { type: pieceOrder[col], color: "white" } } return board } export function createInitialGameState(gameMode: "pvp" | "bot" | "online" = "pvp"): GameState { return { board: createInitialBoard(), currentPlayer: "white", moves: [], isCheck: false, isCheckmate: false, whiteTime: 600000, // 10 minutes in milliseconds blackTime: 600000, gameMode, } } export function isValidMove(board: (ChessPiece | null)[][], from: Position, to: Position): boolean { const piece = board[from.row][from.col] if (!piece) return false const targetPiece = board[to.row][to.col] if (targetPiece && targetPiece.color === piece.color) return false const rowDiff = to.row - from.row const colDiff = to.col - from.col switch (piece.type) { case "pawn": return isValidPawnMove(piece, from, to, rowDiff, colDiff, targetPiece) case "rook": return isValidRookMove(board, from, to, rowDiff, colDiff) case "knight": return isValidKnightMove(rowDiff, colDiff) case "bishop": return isValidBishopMove(board, from, to, rowDiff, colDiff) case "queen": return isValidQueenMove(board, from, to, rowDiff, colDiff) case "king": return isValidKingMove(rowDiff, colDiff) default: return false } } function isValidPawnMove( piece: ChessPiece, from: Position, to: Position, rowDiff: number, colDiff: number, targetPiece: ChessPiece | null, ): boolean { const direction = piece.color === "white" ? -1 : 1 const startRow = piece.color === "white" ? 6 : 1 // Forward move if (colDiff === 0 && !targetPiece) { if (rowDiff === direction) return true if (from.row === startRow && rowDiff === 2 * direction) return true } // Capture if (Math.abs(colDiff) === 1 && rowDiff === direction && targetPiece) { return true } return false } function isValidRookMove( board: (ChessPiece | null)[][], from: Position, to: Position, rowDiff: number, colDiff: number, ): boolean { if (rowDiff !== 0 && colDiff !== 0) return false return isPathClear(board, from, to) } function isValidKnightMove(rowDiff: number, colDiff: number): boolean { return (Math.abs(rowDiff) === 2 && Math.abs(colDiff) === 1) || (Math.abs(rowDiff) === 1 && Math.abs(colDiff) === 2) } function isValidBishopMove( board: (ChessPiece | null)[][], from: Position, to: Position, rowDiff: number, colDiff: number, ): boolean { if (Math.abs(rowDiff) !== Math.abs(colDiff)) return false return isPathClear(board, from, to) } function isValidQueenMove( board: (ChessPiece | null)[][], from: Position, to: Position, rowDiff: number, colDiff: number, ): boolean { return isValidRookMove(board, from, to, rowDiff, colDiff) || isValidBishopMove(board, from, to, rowDiff, colDiff) } function isValidKingMove(rowDiff: number, colDiff: number): boolean { return Math.abs(rowDiff) <= 1 && Math.abs(colDiff) <= 1 } function isPathClear(board: (ChessPiece | null)[][], from: Position, to: Position): boolean { const rowStep = to.row > from.row ? 1 : to.row < from.row ? -1 : 0 const colStep = to.col > from.col ? 1 : to.col < from.col ? -1 : 0 let currentRow = from.row + rowStep let currentCol = from.col + colStep while (currentRow !== to.row || currentCol !== to.col) { if (board[currentRow][currentCol] !== null) return false currentRow += rowStep currentCol += colStep } return true } export function makeMove(gameState: GameState, from: Position, to: Position): GameState | null { if (!isValidMove(gameState.board, from, to)) return null const newBoard = gameState.board.map((row) => [...row]) const piece = newBoard[from.row][from.col] const capturedPiece = newBoard[to.row][to.col] // Check if king is being captured const isKingCaptured = capturedPiece && capturedPiece.type === "king" newBoard[to.row][to.col] = piece newBoard[from.row][from.col] = null const move: Move = { from, to, piece: piece!, capturedPiece: capturedPiece || undefined, } const nextPlayer = gameState.currentPlayer === "white" ? "black" : "white" // Check for check and checkmate const isCheck = isInCheck(newBoard, nextPlayer) const isCheckmate = isKingCaptured || (isCheck && isInCheckmate(newBoard, nextPlayer)) return { ...gameState, board: newBoard, currentPlayer: isCheckmate ? gameState.currentPlayer : nextPlayer, // Don't switch if checkmate moves: [...gameState.moves, move], isCheck, isCheckmate, } } export function isInCheck(board: (ChessPiece | null)[][], color: PieceColor): boolean { const kingPosition = findKing(board, color) if (!kingPosition) return false for (let row = 0; row < 8; row++) { for (let col = 0; col < 8; col++) { const piece = board[row][col] if (piece && piece.color !== color) { if (isValidMove(board, { row, col }, kingPosition)) { return true } } } } return false } function isInCheckmate(board: (ChessPiece | null)[][], color: PieceColor): boolean { // If king is missing, it's checkmate if (!findKing(board, color)) return true // Check if any move can get out of check for (let fromRow = 0; fromRow < 8; fromRow++) { for (let fromCol = 0; fromCol < 8; fromCol++) { const piece = board[fromRow][fromCol] if (piece && piece.color === color) { for (let toRow = 0; toRow < 8; toRow++) { for (let toCol = 0; toCol < 8; toCol++) { const from = { row: fromRow, col: fromCol } const to = { row: toRow, col: toCol } if (isValidMove(board, from, to)) { // Simulate the move const testBoard = board.map((row) => [...row]) testBoard[toRow][toCol] = testBoard[fromRow][fromCol] testBoard[fromRow][fromCol] = null // If this move gets out of check, it's not checkmate if (!isInCheck(testBoard, color)) { return false } } } } } } } return true } function findKing(board: (ChessPiece | null)[][], color: PieceColor): Position | null { for (let row = 0; row < 8; row++) { for (let col = 0; col < 8; col++) { const piece = board[row][col] if (piece && piece.type === "king" && piece.color === color) { return { row, col } } } } return null } export function getAllValidMoves(board: (ChessPiece | null)[][], color: PieceColor): Move[] { const moves: Move[] = [] for (let fromRow = 0; fromRow < 8; fromRow++) { for (let fromCol = 0; fromCol < 8; fromCol++) { const piece = board[fromRow][fromCol] if (piece && piece.color === color) { for (let toRow = 0; toRow < 8; toRow++) { for (let toCol = 0; toCol < 8; toCol++) { const from = { row: fromRow, col: fromCol } const to = { row: toRow, col: toCol } if (isValidMove(board, from, to)) { moves.push({ from, to, piece, capturedPiece: board[toRow][toCol] || undefined, }) } } } } } } return moves } export function getRandomMove(board: (ChessPiece | null)[][], color: PieceColor): Move | null { const validMoves = getAllValidMoves(board, color) if (validMoves.length === 0) return null return validMoves[Math.floor(Math.random() * validMoves.length)] } export function getGameResult(gameState: GameState): string | null { if (gameState.isCheckmate) { const winner = gameState.currentPlayer === "white" ? "PlayerWhite" : "PlayerBlack" return `${winner} wins by checkmate!` } if (gameState.whiteTime <= 0) { return "PlayerBlack wins by timeout!" } if (gameState.blackTime <= 0) { return "PlayerWhite wins by timeout!" } return null } [V0_FILE]typescriptreact:file="components/chess-board.tsx" isEdit="true" isMerged="true" "use client" import { useState } from "react" import type { GameState, Position } from "@/lib/types" import { makeMove, isValidMove } from "@/lib/chess-logic" import { useTheme } from "@/lib/theme-context" import ChessPieceComponent from "./chess-piece" interface ChessBoardProps { gameState: GameState onGameStateChange: (gameState: GameState) => void onMove?: (from: Position, to: Position) => void } export default function ChessBoard({ gameState, onGameStateChange, onMove }: ChessBoardProps) { const [selectedSquare, setSelectedSquare] = useState(null) const [validMoves, setValidMoves] = useState([]) const { colors } = useTheme() const handleSquareClick = (row: number, col: number) => { // Don't allow moves if game is over if (gameState.isCheckmate) return const position = { row, col } const piece = gameState.board[row][col] if (selectedSquare) { // Try to make a move if (validMoves.some((move) => move.row === row && move.col === col)) { const newGameState = makeMove(gameState, selectedSquare, position) if (newGameState) { onGameStateChange(newGameState) onMove?.(selectedSquare, position) } } setSelectedSquare(null) setValidMoves([]) } else if (piece && piece.color === gameState.currentPlayer) { // Select a piece setSelectedSquare(position) // Calculate valid moves const moves: Position[] = [] for (let r = 0; r < 8; r++) { for (let c = 0; c < 8; c++) { if (isValidMove(gameState.board, position, { row: r, col: c })) { moves.push({ row: r, col: c }) } } } setValidMoves(moves) } } const isSquareSelected = (row: number, col: number) => { return selectedSquare?.row === row && selectedSquare?.col === col } const isValidMoveSquare = (row: number, col: number) => { return validMoves.some((move) => move.row === row && move.col === col) } const getSquareColor = (row: number, col: number) => { const isLight = (row + col) % 2 === 0 if (isSquareSelected(row, col)) { return colors.highlight } if (isValidMoveSquare(row, col)) { return `${colors.highlight}80` // Semi-transparent highlight } return isLight ? colors.lightSquare : colors.darkSquare } return (

{gameState.board.map((row, rowIndex) => row.map((piece, colIndex) => (

handleSquareClick(rowIndex, colIndex)} > {piece && }

)), )}

{gameState.isCheckmate && (

Game Over!

{gameState.currentPlayer === "white" ? "PlayerWhite" : "PlayerBlack"} wins!

)}

) } [V0_FILE]typescriptreact:file="lib/theme-context.tsx" isEdit="true" isMerged="true" "use client" import type React from "react" import { createContext, useContext, useState, useEffect } from "react" import type { Theme, ThemeColors } from "./types" const themes: Record = { "ocean-breeze": { lightSquare: "#B8E6E6", darkSquare: "#4A9FD9", highlight: "#FFD700", check: "#FF4444", }, "black-silver": { lightSquare: "#A8A8A8", darkSquare: "#404040", highlight: "#FFD700", check: "#FF4444", }, "forest-canopy": { lightSquare: "#C8E6C9", darkSquare: "#4CAF50", highlight: "#FFD700", check: "#FF4444", }, "beige-brown": { lightSquare: "#F5DEB3", darkSquare: "#D2691E", highlight: "#FFD700", check: "#FF4444", }, } interface ThemeContextType { theme: Theme setTheme: (theme: Theme) => void colors: ThemeColors } const ThemeContext = createContext(undefined) export function ThemeProvider({ children }: { children: React.ReactNode }) { const [theme, setTheme] = useState("black-silver") useEffect(() => { const savedTheme = localStorage.getItem("boardwise-theme") as Theme if (savedTheme && themes[savedTheme]) { setTheme(savedTheme) } }, []) useEffect(() => { localStorage.setItem("boardwise-theme", theme) document.documentElement.style.setProperty("--light-square", themes[theme].lightSquare) document.documentElement.style.setProperty("--dark-square", themes[theme].darkSquare) document.documentElement.style.setProperty("--highlight", themes[theme].highlight) document.documentElement.style.setProperty("--check", themes[theme].check) }, [theme]) return {children} } export function useTheme() { const context = useContext(ThemeContext) if (!context) { throw new Error("useTheme must be used within a ThemeProvider") } return context } [V0_FILE]typescriptreact:file="lib/chess-engine.ts" isMerged="true" import type { ChessPiece, Move, GameState, PieceColor } from "./types" import { getAllValidMoves, makeMove, isInCheck } from "./chess-logic" // Piece values for evaluation const PIECE_VALUES = { pawn: 100, knight: 320, bishop: 330, rook: 500, queen: 900, king: 20000, } // Position bonus tables for better piece placement const PAWN_TABLE = [ [0, 0, 0, 0, 0, 0, 0, 0], [50, 50, 50, 50, 50, 50, 50, 50], [10, 10, 20, 30, 30, 20, 10, 10], [5, 5, 10, 25, 25, 10, 5, 5], [0, 0, 0, 20, 20, 0, 0, 0], [5, -5, -10, 0, 0, -10, -5, 5], [5, 10, 10, -20, -20, 10, 10, 5], [0, 0, 0, 0, 0, 0, 0, 0], ] const KNIGHT_TABLE = [ [-50, -40, -30, -30, -30, -30, -40, -50], [-40, -20, 0, 0, 0, 0, -20, -40], [-30, 0, 10, 15, 15, 10, 0, -30], [-30, 5, 15, 20, 20, 15, 5, -30], [-30, 0, 15, 20, 20, 15, 0, -30], [-30, 5, 10, 15, 15, 10, 5, -30], [-40, -20, 0, 5, 5, 0, -20, -40], [-50, -40, -30, -30, -30, -30, -40, -50], ] const BISHOP_TABLE = [ [-20, -10, -10, -10, -10, -10, -10, -20], [-10, 0, 0, 0, 0, 0, 0, -10], [-10, 0, 5, 10, 10, 5, 0, -10], [-10, 5, 5, 10, 10, 5, 5, -10], [-10, 0, 10, 10, 10, 10, 0, -10], [-10, 10, 10, 10, 10, 10, 10, -10], [-10, 5, 0, 0, 0, 0, 5, -10], [-20, -10, -10, -10, -10, -10, -10, -20], ] const ROOK_TABLE = [ [0, 0, 0, 0, 0, 0, 0, 0], [5, 10, 10, 10, 10, 10, 10, 5], [-5, 0, 0, 0, 0, 0, 0, -5], [-5, 0, 0, 0, 0, 0, 0, -5], [-5, 0, 0, 0, 0, 0, 0, -5], [-5, 0, 0, 0, 0, 0, 0, -5], [-5, 0, 0, 0, 0, 0, 0, -5], [0, 0, 0, 5, 5, 0, 0, 0], ] const QUEEN_TABLE = [ [-20, -10, -10, -5, -5, -10, -10, -20], [-10, 0, 0, 0, 0, 0, 0, -10], [-10, 0, 5, 5, 5, 5, 0, -10], [-5, 0, 5, 5, 5, 5, 0, -5], [0, 0, 5, 5, 5, 5, 0, -5], [-10, 5, 5, 5, 5, 5, 0, -10], [-10, 0, 5, 0, 0, 0, 0, -10], [-20, -10, -10, -5, -5, -10, -10, -20], ] const KING_MIDDLE_GAME_TABLE = [ [-30, -40, -40, -50, -50, -40, -40, -30], [-30, -40, -40, -50, -50, -40, -40, -30], [-30, -40, -40, -50, -50, -40, -40, -30], [-30, -40, -40, -50, -50, -40, -40, -30], [-20, -30, -30, -40, -40, -30, -30, -20], [-10, -20, -20, -20, -20, -20, -20, -10], [20, 20, 0, 0, 0, 0, 20, 20], [20, 30, 10, 0, 0, 10, 30, 20], ] function getPiecePositionValue(piece: ChessPiece, row: number, col: number): number { const adjustedRow = piece.color === "white" ? 7 - row : row switch (piece.type) { case "pawn": return PAWN_TABLE[adjustedRow][col] case "knight": return KNIGHT_TABLE[adjustedRow][col] case "bishop": return BISHOP_TABLE[adjustedRow][col] case "rook": return ROOK_TABLE[adjustedRow][col] case "queen": return QUEEN_TABLE[adjustedRow][col] case "king": return KING_MIDDLE_GAME_TABLE[adjustedRow][col] default: return 0 } } function evaluateBoard(board: (ChessPiece | null)[][], color: PieceColor): number { let score = 0 for (let row = 0; row < 8; row++) { for (let col = 0; col < 8; col++) { const piece = board[row][col] if (piece) { const pieceValue = PIECE_VALUES[piece.type] const positionValue = getPiecePositionValue(piece, row, col) const totalValue = pieceValue + positionValue if (piece.color === color) { score += totalValue } else { score -= totalValue } } } } // Bonus for controlling center const centerSquares = [ [3, 3], [3, 4], [4, 3], [4, 4], ] for (const [row, col] of centerSquares) { const piece = board[row][col] if (piece) { if (piece.color === color) { score += 30 } else { score -= 30 } } } // Penalty for being in check if (isInCheck(board, color)) { score -= 50 } return score } function minimax( gameState: GameState, depth: number, alpha: number, beta: number, maximizingPlayer: boolean, botColor: PieceColor, ): { score: number; move: Move | null } { if (depth === 0 || gameState.isCheckmate) { return { score: evaluateBoard(gameState.board, botColor), move: null, } } const currentColor = maximizingPlayer ? botColor : botColor === "white" ? "black" : "white" const validMoves = getAllValidMoves(gameState.board, currentColor) if (validMoves.length === 0) { return { score: maximizingPlayer ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY, move: null, } } let bestMove: Move | null = null if (maximizingPlayer) { let maxEval = Number.NEGATIVE_INFINITY for (const move of validMoves) { const newGameState = makeMove(gameState, move.from, move.to) if (newGameState) { const evaluation = minimax(newGameState, depth - 1, alpha, beta, false, botColor) if (evaluation.score > maxEval) { maxEval = evaluation.score bestMove = move } alpha = Math.max(alpha, evaluation.score) if (beta <= alpha) { break // Alpha-beta pruning } } } return { score: maxEval, move: bestMove } } else { let minEval = Number.POSITIVE_INFINITY for (const move of validMoves) { const newGameState = makeMove(gameState, move.from, move.to) if (newGameState) { const evaluation = minimax(newGameState, depth - 1, alpha, beta, true, botColor) if (evaluation.score < minEval) { minEval = evaluation.score bestMove = move } beta = Math.min(beta, evaluation.score) if (beta <= alpha) { break // Alpha-beta pruning } } } return { score: minEval, move: bestMove } } } export function getBestMove(gameState: GameState, difficulty: "easy" | "medium" | "hard" = "medium"): Move | null { const botColor = "black" // Bot always plays as black // Adjust search depth based on difficulty const depth = { easy: 2, medium: 3, hard: 4, }[difficulty] console.log(`🤖 Chess Engine thinking at ${difficulty} difficulty (depth: ${depth})...`) const startTime = Date.now() const result = minimax(gameState, depth, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, true, botColor) const endTime = Date.now() console.log(`🤖 Analysis complete in ${endTime - startTime}ms`) console.log(`🤖 Best move evaluation: ${result.score}`) if (result.move) { const from = `${String.fromCharCode(97 + result.move.from.col)}${8 - result.move.from.row}` const to = `${String.fromCharCode(97 + result.move.to.col)}${8 - result.move.to.row}` console.log(`🤖 Playing: ${from} → ${to}`) } return result.move } export function getRandomMove(board: (ChessPiece | null)[][], color: PieceColor): Move | null { const validMoves = getAllValidMoves(board, color) if (validMoves.length === 0) return null return validMoves[Math.floor(Math.random() * validMoves.length)] } // Fallback function that combines smart play with some randomness for easier difficulties export function getSmartRandomMove(gameState: GameState, difficulty: "easy" | "medium" | "hard"): Move | null { const botColor = "black" const validMoves = getAllValidMoves(gameState.board, botColor) if (validMoves.length === 0) return null // For easy difficulty, mix random moves with some smart moves if (difficulty === "easy" && Math.random() < 0.4) { console.log("🤖 Playing random move (easy mode)") return validMoves[Math.floor(Math.random() * validMoves.length)] } // Look for captures and good moves const captureMoves = validMoves.filter((move) => move.capturedPiece) const centerMoves = validMoves.filter( (move) => move.to.row >= 3 && move.to.row <= 4 && move.to.col >= 3 && move.to.col <= 4, ) // Prioritize captures if (captureMoves.length > 0 && Math.random() < 0.7) { console.log("🤖 Playing capture move") return captureMoves[Math.floor(Math.random() * captureMoves.length)] } // Then center control if (centerMoves.length > 0 && Math.random() < 0.5) { console.log("🤖 Playing center control move") return centerMoves[Math.floor(Math.random() * centerMoves.length)] } // Otherwise random valid move console.log("🤖 Playing strategic move") return validMoves[Math.floor(Math.random() * validMoves.length)] } [V0_FILE]typescriptreact:file="app/modes/page.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { useRouter } from "next/navigation" export default function ModesPage() { const router = useRouter() const handleGameMode = (mode: string) => { if (mode === "online") { router.push("/online") } else if (mode === "bot") { router.push("/bot") } else { router.push(`/play?mode=${mode}`) } } return (

𝔹𝕆𝔸ℝ𝔻𝕨𝕚𝕤𝕖

) } [V0_FILE]typescriptreact:file="app/bot/page.tsx" isEdit="true" isMerged="true" "use client" import { useRouter } from "next/navigation" import { Button } from "@/components/ui/button" import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card" export default function BotSetupPage() { const router = useRouter() const difficulties = [ { level: "easy", title: "Easy Bot", description: "Perfect for beginners. Makes some random moves and basic strategy.", icon: "🟢", features: ["Random moves mixed in", "Basic piece values", "2-move lookahead"], }, { level: "medium", title: "Medium Bot", description: "Good challenge for intermediate players. Strategic thinking.", icon: "🟡", features: ["Strategic play", "Position evaluation", "3-move lookahead"], }, { level: "hard", title: "Hard Bot", description: "Advanced chess engine. Challenging for experienced players.", icon: "🔴", features: ["Advanced tactics", "Deep analysis", "4-move lookahead"], }, ] const handleDifficultySelect = (difficulty: string) => { router.push(`/play?mode=bot&difficulty=${difficulty}`) } return (

𝔹𝕆𝔸ℝ𝔻𝕨𝕚𝕤𝕖 - Choose Your Opponent

Select the difficulty level for your chess engine opponent

{difficulties.map((diff) => (

handleDifficultySelect(diff.level)}>

{diff.icon}

{diff.title}

{diff.description}

Features:

{feature}

))}

) } [V0_FILE]typescriptreact:file="app/play/page.tsx" isEdit="true" "use client" import { useState, useEffect, useCallback } from "react" import { useRouter, useSearchParams } from "next/navigation" import { Button } from "@/components/ui/button" import ChessBoard from "@/components/chess-board" import GameTimer from "@/components/game-timer" import ThemeSwitcher from "@/components/theme-switcher" import { useTheme } from "@/lib/theme-context" import type { GameState } from "@/lib/types" import { createInitialGameState, makeMove, getGameResult } from "@/lib/chess-logic" import { getBestMove, getSmartRandomMove } from "@/lib/chess-engine" export default function PlayPage() { const router = useRouter() const searchParams = useSearchParams() const { theme } = useTheme() const mode = searchParams.get("mode") || "pvp" const gameId = searchParams.get("gameId") const playerColor = searchParams.get("color") const urlDifficulty = searchParams.get("difficulty") as "easy" | "medium" | "hard" | null const [countdown, setCountdown] = useState(5) const [gameStarted, setGameStarted] = useState(false) const [gameState, setGameState] = useState(() => createInitialGameState(mode as "pvp" | "bot" | "online")) const [gameResult, setGameResult] = useState(null) const [botDifficulty, setBotDifficulty] = useState<"easy" | "medium" | "hard">(urlDifficulty || "medium") const [botThinking, setBotThinking] = useState(false) // Countdown timer useEffect(() => { if (countdown > 0) { const timer = setTimeout(() => setCountdown(countdown - 1), 1000) return () => clearTimeout(timer) } else { setGameStarted(true) } }, [countdown]) // Timer system - only runs for PvP and Online modes, not for bot mode useEffect(() => { if (!gameStarted || gameState.isCheckmate || mode === "bot") return const interval = setInterval(() => { setGameState((prev) => { const newState = { ...prev } // Only run timers for PvP/Online mode if (prev.currentPlayer === "white") { newState.whiteTime = Math.max(0, prev.whiteTime - 1000) } else { newState.blackTime = Math.max(0, prev.blackTime - 1000) } return newState }) }, 1000) return () => clearInterval(interval) }, [gameStarted, gameState.currentPlayer, gameState.isCheckmate, mode]) // Check for game end conditions useEffect(() => { const result = getGameResult(gameState) if (result) { setGameResult(result) } }, [gameState]) // Enhanced AI Bot logic const makeBotMove = useCallback(async () => { if (mode !== "bot" || gameState.currentPlayer !== "black" || gameState.isCheckmate) return setBotThinking(true) try { console.log(`🤖 Chess Engine analyzing position at ${botDifficulty} difficulty...`) // Add thinking delay for realism - no timer pressure in bot mode await new Promise((resolve) => setTimeout(resolve, 800 + Math.random() * 1200)) let botMove = null // Try the advanced engine first try { botMove = getBestMove(gameState, botDifficulty) } catch (error) { console.warn("🤖 Advanced engine failed, using fallback:", error) botMove = getSmartRandomMove(gameState, botDifficulty) } if (botMove) { const newGameState = makeMove(gameState, botMove.from, botMove.to) if (newGameState) { setGameState(newGameState) console.log("🤖 Bot move executed successfully") } } else { console.log("🤖 No valid moves available for bot") } } catch (error) { console.error("🤖 Bot move failed:", error) // Final fallback - try any random valid move const fallbackMove = getSmartRandomMove(gameState, "easy") if (fallbackMove) { const newGameState = makeMove(gameState, fallbackMove.from, fallbackMove.to) if (newGameState) { setGameState(newGameState) } } } finally { setBotThinking(false) } }, [mode, gameState, botDifficulty]) useEffect(() => { if ( gameStarted && mode === "bot" && gameState.currentPlayer === "black" && !gameState.isCheckmate && !botThinking ) { const timer = setTimeout(makeBotMove, 300) return () => clearTimeout(timer) } }, [gameStarted, mode, gameState.currentPlayer, gameState.isCheckmate, makeBotMove, botThinking]) const handleGameStateChange = (newGameState: GameState) => { setGameState(newGameState) if (mode === "online" && gameId) { console.log("Syncing game state to Firebase:", gameId) } } const handleTimeUp = () => { console.log("Time up!") const result = getGameResult(gameState) if (result) { setGameResult(result) } } const handleNewGame = () => { setGameState(createInitialGameState(mode as "pvp" | "bot" | "online")) setGameResult(null) setBotThinking(false) } const getThemeClass = () => { switch (theme) { case "ocean-breeze": return "theme-ocean-breeze" case "black-silver": return "theme-black-silver" case "forest-canopy": return "theme-forest-canopy" case "beige-brown": return "theme-beige-brown" default: return "theme-black-silver" } } const getTextColor = () => { return theme === "black-silver" ? "text-white" : "text-gray-800" } if (!gameStarted) { return (

{countdown}

Game starting...

) } return (

{/* Header */}

{gameResult && ( )} {mode === "bot" && ( )}

{/* Game Result */} {gameResult && (

Game Over!

{gameResult}

)} {/* Current Player Indicator */} {!gameResult && (

{gameState.currentPlayer === "white" ? ( "PlayerWhite's turn" ) : botThinking ? (

Bot is thinking...

) : ( "PlayerBlack's turn" )}

)} {/* Game Area */}

{/* Chess Board */} {/* Timers - Only show for PvP and Online modes, hidden for bot mode */} {mode !== "bot" && (

)}

{/* Game Info */} {mode === "online" && gameId && (

Game ID: {gameId}

You are playing as {playerColor === "white" ? "White" : "Black"}

)}

) }