function MainComponent() { const DEBUG_LEVEL = 0; // 0: No logs, 1: Basic flow, 2: Detailed minimax/eval // Helper for conditional logging const log = useCallback((level, ...args)=>{ if (DEBUG_LEVEL >= level) { const logArgs = args.map((arg)=>{ if (typeof arg === "object" && arg !== null) { try { return JSON.parse(JSON.stringify(arg)); } catch (e) { return arg; } } return arg; }); console.log("[Shogi]", ...logArgs); } }, []); // ============================================================ // 内部定数定義 // ============================================================ const pieceValues = { 歩: 100, 香: 300, 桂: 320, 銀: 480, 金: 520, 角: 850, 飛: 950, 玉: 20000, 王: 20000, と: 550, 杏: 500, 圭: 500, 全: 500, 馬: 1050, 龍: 1250 }; const promotableOriginalTypes = [ "歩", "香", "桂", "銀", "角", "飛" ]; const initialPieceTypesForHand = [ "歩", "香", "桂", "銀", "金", "角", "飛" ]; const rowChars = [ "一", "二", "三", "四", "五", "六", "七", "八", "九" ]; const pst_pawn = [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 5, 5, 5, 5, 5, 5, 5, 5, 5 ], [ 10, 10, 10, 10, 10, 10, 10, 10, 10 ], [ 15, 15, 15, 15, 15, 15, 15, 15, 15 ], [ 20, 20, 20, 20, 20, 20, 20, 20, 20 ], [ 20, 20, 20, 20, 20, 20, 20, 20, 20 ], [ 15, 15, 15, 15, 15, 15, 15, 15, 15 ], [ 10, 10, 10, 10, 10, 10, 10, 10, 10 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ]; const pst_lance = [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 2, 2, 3, 3, 3, 3, 3, 2, 2 ], [ 4, 4, 5, 5, 5, 5, 5, 4, 4 ], [ 6, 6, 7, 7, 7, 7, 7, 6, 6 ], [ 8, 8, 9, 9, 9, 9, 9, 8, 8 ], [ 8, 8, 9, 9, 9, 9, 9, 8, 8 ], [ 6, 6, 7, 7, 7, 7, 7, 6, 6 ], [ 4, 4, 5, 5, 5, 5, 5, 4, 4 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ]; const pst_knight = [ [ -5, -3, 0, 2, 2, 2, 0, -3, -5 ], [ -3, 0, 4, 5, 5, 5, 4, 0, -3 ], [ 0, 4, 6, 7, 7, 7, 6, 4, 0 ], [ 2, 5, 7, 8, 8, 8, 7, 5, 2 ], [ 2, 5, 7, 8, 8, 8, 7, 5, 2 ], [ 0, 4, 6, 7, 7, 7, 6, 4, 0 ], [ -3, 0, 4, 5, 5, 5, 4, 0, -3 ], [ -5, -3, 0, 2, 2, 2, 0, -3, -5 ], [ -10, -5, -3, 0, 0, 0, -3, -5, -10 ] ]; const pst_silver = [ [ -5, 0, 0, 1, 1, 1, 0, 0, -5 ], [ 0, 0, 5, 5, 5, 5, 5, 0, 0 ], [ 0, 5, 8, 8, 8, 8, 8, 5, 0 ], [ 1, 5, 8, 10, 10, 10, 8, 5, 1 ], [ 0, 5, 8, 10, 10, 10, 8, 5, 0 ], [ 0, 5, 8, 8, 8, 8, 8, 5, 0 ], [ 0, 0, 5, 5, 5, 5, 5, 0, 0 ], [ -5, 0, 2, 2, 2, 2, 2, 0, -5 ], [ -5, -5, 0, 0, 0, 0, 0, -5, -5 ] ]; const pst_gold = [ [ -5, -5, 0, 2, 2, 2, 0, -5, -5 ], [ -5, 0, 5, 5, 5, 5, 5, 0, -5 ], [ 0, 5, 8, 8, 8, 8, 8, 5, 0 ], [ 2, 5, 8, 10, 10, 10, 8, 5, 2 ], [ 2, 5, 8, 10, 10, 10, 8, 5, 2 ], [ 0, 5, 8, 10, 10, 10, 8, 5, 0 ], [ 0, 5, 8, 8, 8, 8, 8, 5, 0 ], [ -5, 0, 5, 5, 5, 5, 5, 0, -5 ], [ -5, -5, 0, 2, 2, 2, 0, -5, -5 ] ]; const pst_bishop = [ [ -5, -5, -5, -5, -5, -5, -5, -5, -5 ], [ -5, 0, 0, 2, 2, 2, 0, 0, -5 ], [ -5, 0, 5, 5, 5, 5, 5, 0, -5 ], [ -5, 2, 5, 10, 10, 10, 5, 2, -5 ], [ -5, 2, 5, 10, 12, 10, 5, 2, -5 ], [ -5, 2, 5, 10, 10, 10, 5, 2, -5 ], [ -5, 0, 5, 5, 5, 5, 5, 0, -5 ], [ -5, 0, 0, 2, 2, 2, 0, 0, -5 ], [ -5, -5, -5, -5, -5, -5, -5, -5, -5 ] ]; const pst_rook = [ [ -5, -5, -5, -3, -3, -3, -5, -5, -5 ], [ -3, 0, 0, 5, 5, 5, 0, 0, -3 ], [ -3, 0, 5, 8, 8, 8, 5, 0, -3 ], [ -3, 5, 8, 10, 10, 10, 8, 5, -3 ], [ -3, 5, 8, 10, 10, 10, 8, 5, -3 ], [ -3, 5, 8, 10, 10, 10, 8, 5, -3 ], [ -3, 0, 5, 8, 8, 8, 5, 0, -3 ], [ -3, 0, 0, 5, 5, 5, 0, 0, -3 ], [ -5, -5, -5, -3, -3, -3, -5, -5, -5 ] ]; const pst_king = [ [ -10, -10, -8, -8, -8, -8, -10, -10 ], [ -8, -5, -2, 0, 0, 0, -2, -5, -8 ], [ -8, -2, 2, 4, 4, 4, 2, -2, -8 ], [ -8, 0, 4, 6, 6, 6, 4, 0, -8 ], [ -8, 0, 4, 6, 6, 6, 4, 0, -8 ], [ -8, -2, 2, 4, 4, 4, 2, -2, -8 ], [ -8, -5, -2, 0, 0, 0, -2, -5, -8 ], [ -10, -10, -8, -8, -8, -8, -10, -10 ] ]; // ============================================================ // 状態定義 // ============================================================ const [board, setBoard] = useState(()=>Array.from({ length: 9 }).fill().map(()=>Array.from({ length: 9 }).fill(null))); const [playerHand, setPlayerHand] = useState(()=>{ const hand = {}; initialPieceTypesForHand.forEach((t)=>{ hand[t] = 0; }); return hand; }); const [enemyHand, setEnemyHand] = useState(()=>{ const hand = {}; initialPieceTypesForHand.forEach((t)=>{ hand[t] = 0; }); return hand; }); const [currentPlayer, setCurrentPlayer] = useState("player"); const [selectedPiece, setSelectedPiece] = useState(null); const [selectedCell, setSelectedCell] = useState(null); const [moveHistory, setMoveHistory] = useState([]); const [gameOver, setGameOver] = useState(false); const [gameStatus, setGameStatus] = useState("あなたの番です（先手）"); const [thinking, setThinking] = useState(false); const [showPromotionModal, setShowPromotionModal] = useState(false); const [promotionArgs, setPromotionArgs] = useState(null); const [aiDifficulty, setAiDifficulty] = useState("medium"); const aiThinkTimeoutRef = useRef(null); // ============================================================ // ヘルパー関数定義 (function 宣言) // ============================================================ function deepCopyGameState(currentBoard, currentPHand, currentEHand) { const newBoard = currentBoard.map((row)=>row.map((p)=>p ? { ...p } : null)); const newPlayerHand = { ...currentPHand }; const newEnemyHand = { ...currentEHand }; return { newBoard, newPlayerHand, newEnemyHand }; } function getPstValue(piece, r, c) { let table = null; let pstR = piece.owner === "player" ? r : 8 - r; let pstC = piece.owner === "player" ? c : 8 - c; const type = piece.originalType; switch(type){ case "歩": table = pst_pawn; break; case "香": table = pst_lance; break; case "桂": table = pst_knight; break; case "銀": table = pst_silver; break; case "金": table = pst_gold; break; case "角": table = pst_bishop; break; case "飛": table = pst_rook; break; case "玉": case "王": table = pst_king; break; default: table = null; } let value = table ? table[pstR]?.[pstC] ?? 0 : 0; return value * (piece.owner === "enemy" ? 1 : -1); } function getPromotedPiece(piece) { if (!piece) return null; const newPiece = { ...piece }; switch(piece.originalType){ case "歩": newPiece.type = "と"; break; case "香": newPiece.type = "杏"; break; case "桂": newPiece.type = "圭"; break; case "銀": newPiece.type = "全"; break; case "角": newPiece.type = "馬"; break; case "飛": newPiece.type = "龍"; break; default: return piece; } return newPiece; } function getPromotedType(originalType) { switch(originalType){ case "歩": return "と"; case "香": return "杏"; case "桂": return "圭"; case "銀": return "全"; case "角": return "馬"; case "飛": return "龍"; default: return originalType; } } function shouldAIPromote(piece, toRow) { if ([ "銀", "角", "飛" ].includes(piece.originalType)) return true; if (piece.originalType === "歩" && toRow >= 6) return Math.random() < 0.8; if (piece.originalType === "香" && toRow >= 6) return Math.random() < 0.9; if (piece.originalType === "桂" && toRow >= 7) return Math.random() < 0.9; return false; } function mustPromote(piece, toRow) { const t = piece.originalType; if (piece.owner === "player") { if (toRow === 0 && (t === "歩" || t === "香")) return true; if (toRow <= 1 && t === "桂") return true; } else { if (toRow === 8 && (t === "歩" || t === "香")) return true; if (toRow >= 7 && t === "桂") return true; } return false; } // ★★★ getValidMovesForBoard: 必ず配列を返すように修正 ★★★ function getValidMovesForBoard(targetBoard, row, col) { if (typeof row !== "number" || typeof col !== "number" || row < 0 || row >= 9 || col < 0 || col >= 9) { console.error("[getValidMovesForBoard Error] Invalid row or col:", row, col); return []; // Invalid coordinates } const p = targetBoard[row]?.[col]; if (!p) { log(2, `[getValidMovesForBoard] No piece at (${row}, ${col})`); return []; // No piece at the specified location } const m = []; const o = p.owner; const t = p.type; const addM = (r, c)=>{ if (r < 0 || r >= 9 || c < 0 || c >= 9) return false; const tg = targetBoard[r]?.[c]; if (tg && tg.owner === o) return false; m.push({ row: r, col: c }); return !tg; }; const addL = (dr, dc)=>{ let r = row + dr, c = col + dc; while(addM(r, c)){ r += dr; c += dc; } }; const pd = o === "player" ? -1 : 1; switch(t){ case "歩": addM(row + pd, col); break; case "香": addL(pd, 0); break; case "桂": addM(row + pd * 2, col - 1); addM(row + pd * 2, col + 1); break; case "銀": addM(row + pd, col); addM(row + pd, col - 1); addM(row + pd, col + 1); addM(row - pd, col - 1); addM(row - pd, col + 1); break; case "金": case "と": case "杏": case "圭": case "全": addM(row + pd, col); addM(row + pd, col - 1); addM(row + pd, col + 1); addM(row, col - 1); addM(row, col + 1); addM(row - pd, col); break; case "角": addL(-1, -1); addL(-1, 1); addL(1, -1); addL(1, 1); break; case "飛": addL(-1, 0); addL(1, 0); addL(0, -1); addL(0, 1); break; case "馬": addL(-1, -1); addL(-1, 1); addL(1, -1); addL(1, 1); addM(row - 1, col); addM(row + 1, col); addM(row, col - 1); addM(row, col + 1); break; case "龍": addL(-1, 0); addL(1, 0); addL(0, -1); addL(0, 1); addM(row - 1, col - 1); addM(row - 1, col + 1); addM(row + 1, col - 1); addM(row + 1, col + 1); break; case "玉": case "王": addM(row - 1, col - 1); addM(row - 1, col); addM(row - 1, col + 1); addM(row, col - 1); addM(row, col + 1); addM(row + 1, col - 1); addM(row + 1, col); addM(row + 1, col + 1); break; } log(2, `[getValidMovesForBoard] Found ${m.length} moves for ${p.type} at (${row}, ${col})`); return m; // 必ず配列 m を返す } function getValidDropPositionsForBoard(targetBoard, type, owner) { const pos = []; let pawnCols = Array.from({ length: 9 }).fill(false); if (type === "歩") { for(let c = 0; c < 9; c++)for(let r = 0; r < 9; r++){ const p = targetBoard[r]?.[c]; if (p && p.owner === owner && p.type === "歩") { pawnCols[c] = true; break; } } } for(let r = 0; r < 9; r++)for(let c = 0; c < 9; c++)if (!targetBoard[r][c]) { let isValid = true; const finalRank = owner === "player" ? 0 : 8; if (type === "歩") { if (pawnCols[c] || r === finalRank) isValid = false; } else if (type === "香") { if (r === finalRank) isValid = false; } else if (type === "桂") { if (owner === "player" && r <= 1 || owner === "enemy" && r >= 7) isValid = false; } if (isValid) pos.push({ row: r, col: c }); } return pos; } function isCheck(kingOwner, currentBoard) { let kingPos = null; const kingType = kingOwner === "player" ? "玉" : "王"; for(let r = 0; r < 9 && !kingPos; r++)for(let c = 0; c < 9; c++){ const p = currentBoard[r]?.[c]; if (p && p.type === kingType && p.owner === kingOwner) { kingPos = { r, c }; break; } } if (!kingPos) return false; const attackerOwner = kingOwner === "player" ? "enemy" : "player"; for(let r = 0; r < 9; r++)for(let c = 0; c < 9; c++){ const p = currentBoard[r]?.[c]; if (p && p.owner === attackerOwner) { const moves = getValidMovesForBoard(currentBoard, r, c); if (moves.some((m)=>m.row === kingPos.r && m.col === kingPos.c)) return true; } } return false; } function moveToString(move) { if (!move || !move.to) return "[Invalid Move Data]"; const piece = move.promotedType || move.piece; const toColNum = typeof move.to.col === "number" ? 9 - move.to.col : "?"; const toRowNum = typeof move.to.row === "number" ? rowChars[move.to.row] : "?"; let notation = ""; if (move.from.isHand) { notation = `${toColNum}${toRowNum}${piece || "?"}打`; } else { const fromColNum = typeof move.from.col === "number" ? 9 - move.from.col : "?"; const fromRowNum = typeof move.from.row === "number" ? rowChars[move.from.row] : "?"; notation = `${fromColNum}${fromRowNum}→${toColNum}${toRowNum}${piece || "?"}`; if (move.isPromotion) notation += "成"; } return notation; } function makeMoveSimulation(move, player, currentBoard, currentPHand, currentEHand) { log(2, `[makeMoveSimulation] Simulating move for ${player}:`, move ? moveToString(move) : "null move"); if (!move) { console.error("[Simulate Error] Received null move object"); return { board: currentBoard, playerHand: currentPHand, enemyHand: currentEHand }; } if (!move.from || !move.to || typeof move.to.row !== "number" || typeof move.to.col !== "number" || !move.from.isHand && (typeof move.from.row !== "number" || typeof move.from.col !== "number")) { console.error("[Simulate Error] Invalid 'from' or 'to' in move object", move); return { board: currentBoard, playerHand: currentPHand, enemyHand: currentEHand }; } const { piece, from, to, isPromotion } = move; const nextBoard = currentBoard.map((row)=>row.map((p)=>p ? { ...p } : null)); let nextPHand = { ...currentPHand }; let nextEHand = { ...currentEHand }; if (from.isHand) { if (player === "player") nextPHand[piece]--; else nextEHand[piece]--; if (player === "player" && nextPHand[piece] < 0 || player === "enemy" && nextEHand[piece] < 0) console.error("[Simulate Error] Drop resulted in negative hand count", move, player === "player" ? currentPHand : currentEHand); nextBoard[to.row][to.col] = { type: piece, owner: player, originalType: piece }; } else { const pieceToMove = nextBoard[from.row]?.[from.col]; if (!pieceToMove) { console.error("[Simulate Error] No piece at source", move); return { board: currentBoard, playerHand: currentPHand, enemyHand: currentEHand }; } const capturedPiece = nextBoard[to.row]?.[to.col]; if (capturedPiece) { const originalType = capturedPiece.originalType; if (initialPieceTypesForHand.includes(originalType)) { if (player === "player") nextPHand[originalType] = (nextPHand[originalType] || 0) + 1; else nextEHand[originalType] = (nextEHand[originalType] || 0) + 1; } else { console.warn("[Simulate Warn] Captured invalid piece type:", originalType); } } nextBoard[to.row][to.col] = { ...pieceToMove }; nextBoard[from.row][from.col] = null; if (isPromotion) nextBoard[to.row][to.col] = getPromotedPiece(nextBoard[to.row][to.col]); } return { board: nextBoard, playerHand: nextPHand, enemyHand: nextEHand }; } function getAllPossibleMoves(player, currentBoard, currentPHand, currentEHand) { log(2, `[getAllPossibleMoves] Generating moves for ${player}`); const moves = []; const cb = currentBoard; for(let r = 0; r < 9; r++)for(let c = 0; c < 9; c++){ const piece = cb[r]?.[c]; if (piece && piece.owner === player) { const destinations = getValidMovesForBoard(cb, r, c); for (const dest of destinations){ const toRow = dest.row; const toCol = dest.col; const capturedPiece = cb[toRow]?.[toCol]; const isPromotableType = promotableOriginalTypes.includes(piece.originalType); const mustPromoteMove = mustPromote(piece, toRow); const isEnteringZone = player === "player" ? toRow <= 2 : toRow >= 6; const isStartingInZone = player === "player" ? r <= 2 : r >= 6; const canPromote = isPromotableType && (isEnteringZone || isStartingInZone) && piece.type === piece.originalType; const moveOptions = []; if (isPromotableType && mustPromoteMove) { moveOptions.push({ isPromotion: true }); } else if (canPromote) { moveOptions.push({ isPromotion: false }); moveOptions.push({ isPromotion: true }); } else { moveOptions.push({ isPromotion: false }); } for (const option of moveOptions){ const moveDataForSim = { piece: piece.originalType, from: { row: r, col: c }, to: { row: toRow, col: toCol }, isCapture: !!capturedPiece, capturedPiece: capturedPiece?.originalType, isPromotion: option.isPromotion, promotedType: option.isPromotion ? getPromotedType(piece.originalType) : null }; const { board: nextBoard } = makeMoveSimulation(moveDataForSim, player, currentBoard, currentPHand, currentEHand); if (!isCheck(player, nextBoard)) { moves.push(moveDataForSim); log(2, ` Added board move:`, moveToString(moveDataForSim)); } else { log(2, ` Illegal board move (check):`, moveToString(moveDataForSim)); } } } } } const hand = player === "player" ? currentPHand : currentEHand; for (const [type, count] of Object.entries(hand))if (count > 0) { const dropPositions = getValidDropPositionsForBoard(cb, type, player); for (const pos of dropPositions){ const moveDataForSim = { piece: type, from: { isHand: true }, to: { row: pos.row, col: pos.col }, isCapture: false, capturedPiece: null, isPromotion: false, promotedType: null }; const { board: nextBoard, playerHand: nextPHand } = makeMoveSimulation(moveDataForSim, player, currentBoard, currentPHand, currentEHand); const isLegal = !isCheck(player, nextBoard) && !(type === "歩" && isPawnDropMateForBoard(nextBoard, player, pos.row, pos.col, nextPHand, currentEHand)); if (isLegal) { moves.push(moveDataForSim); log(2, ` Added drop move:`, moveToString(moveDataForSim)); } else { log(2, ` Illegal drop move:`, moveToString(moveDataForSim), `Self-check: ${isCheck(player, nextBoard)}`, `PawnDropMate: ${type === "歩" && isPawnDropMateForBoard(nextBoard, player, pos.row, pos.col, nextPHand, currentEHand)}`); } } } log(1, `[getAllPossibleMoves] Found ${moves.length} moves for ${player}`); return moves; } function isCheckmate(kingOwner, currentBoard, currentPHand, currentEHand) { if (!isCheck(kingOwner, currentBoard)) return false; const possibleMoves = getAllPossibleMoves(kingOwner, currentBoard, currentPHand, currentEHand); log(2, `[isCheckmate] ${kingOwner} possible moves: ${possibleMoves.length}`); return possibleMoves.length === 0; } function isPawnDropMateForBoard(targetBoard, owner, row, col, currentPHand, currentEHand) { const tempBoard = targetBoard.map((r)=>r.map((p)=>p ? { ...p } : null)); tempBoard[row][col] = { type: "歩", owner: owner, originalType: "歩" }; const opponentOwner = owner === "player" ? "enemy" : "player"; if (!isCheck(opponentOwner, tempBoard)) return false; const opponentHand = opponentOwner === "player" ? currentPHand : currentEHand; const opponentMoves = getAllPossibleMoves(opponentOwner, tempBoard, opponentHand, opponentOwner === "player" ? currentEHand : currentPHand); const isMate = opponentMoves.length === 0; log(2, `[isPawnDropMateForBoard] Check for ${owner} drop at (${row},${col}). Opponent has ${opponentMoves.length} moves. Is Mate: ${isMate}`); return isMate; } function evaluatePosition(currentBoard, currentPHand, currentEHand, playerForTurnBonus) { log(2, `[evaluatePosition] Evaluating for turn: ${playerForTurnBonus}`); let score = 0; let playerKingPos = null; let enemyKingPos = null; let playerMobility = 0; let enemyMobility = 0; let playerConnections = 0; let enemyConnections = 0; for(let r = 0; r < 9; r++)for(let c = 0; c < 9; c++){ const p = currentBoard[r]?.[c]; if (p) { const v = pieceValues[p.type] || 0; const sign = p.owner === "enemy" ? 1 : -1; score += v * sign; score += getPstValue(p, r, c); if (p.type === "玉") playerKingPos = { r, c }; if (p.type === "王") enemyKingPos = { r, c }; const moves = getValidMovesForBoard(currentBoard, r, c); const mobilityWeight = [ "飛", "角", "馬", "龍" ].includes(p.type) ? 3 : 1; if (p.owner === "enemy") enemyMobility += moves.length * mobilityWeight; else playerMobility += moves.length * mobilityWeight; if (p.type === "金" || p.type === "銀") { const offsets = [ [ -1, -1 ], [ -1, 0 ], [ -1, 1 ], [ 0, -1 ], [ 0, 1 ], [ 1, -1 ], [ 1, 0 ], [ 1, 1 ] ]; for (const [dr, dc] of offsets){ const nr = r + dr, nc = c + dc; const n = currentBoard[nr]?.[nc]; if (n && n.owner === p.owner && (n.type === "金" || n.type === "銀")) p.owner === "enemy" ? enemyConnections++ : playerConnections++; } } } } score += (enemyMobility - playerMobility) * 3; score += (enemyConnections / 2 - playerConnections / 2) * 20; const handDiscount = 0.95; for (const [t, c] of Object.entries(currentEHand))score += (pieceValues[t] || 0) * c * handDiscount; for (const [t, c] of Object.entries(currentPHand))score -= (pieceValues[t] || 0) * c * handDiscount; const kingAdjacentBonus = 40; const kingThreatPenalty = 70; if (enemyKingPos) { let safetyScore = 0; for(let dr = -1; dr <= 1; dr++)for(let dc = -1; dc <= 1; dc++){ if (dr === 0 && dc === 0) continue; const nr = enemyKingPos.r + dr, nc = enemyKingPos.c + dc; const n = currentBoard[nr]?.[nc]; if (n && n.owner === "enemy" && (n.type === "金" || n.type === "銀")) safetyScore += kingAdjacentBonus; } for(let dr = -2; dr <= 2; dr++)for(let dc = -2; dc <= 2; dc++){ if (Math.abs(dr) + Math.abs(dc) > 3 || dr === 0 && dc === 0) continue; const nr = enemyKingPos.r + dr, nc = enemyKingPos.c + dc; const t = currentBoard[nr]?.[nc]; if (t && t.owner === "player" && [ "歩", "香", "桂", "飛", "角", "馬", "龍" ].includes(t.type)) safetyScore -= kingThreatPenalty; } if (enemyKingPos.r === 1 && enemyKingPos.c === 1 && currentBoard[0]?.[0]?.type === "香" && currentBoard[0]?.[1]?.type === "桂" && currentBoard[0]?.[2]?.type === "銀" && currentBoard[1]?.[0]?.type === "金" && currentBoard[2]?.[1]?.type === "歩") safetyScore += 150; score += safetyScore; } if (playerKingPos) { let safetyScore = 0; for(let dr = -1; dr <= 1; dr++)for(let dc = -1; dc <= 1; dc++){ if (dr === 0 && dc === 0) continue; const nr = playerKingPos.r + dr, nc = playerKingPos.c + dc; const n = currentBoard[nr]?.[nc]; if (n && n.owner === "player" && (n.type === "金" || n.type === "銀")) safetyScore += kingAdjacentBonus; } for(let dr = -2; dr <= 2; dr++)for(let dc = -2; dc <= 2; dc++){ if (Math.abs(dr) + Math.abs(dc) > 3 || dr === 0 && dc === 0) continue; const nr = playerKingPos.r + dr, nc = playerKingPos.c + dc; const t = currentBoard[nr]?.[nc]; if (t && t.owner === "enemy" && [ "歩", "香", "桂", "飛", "角", "馬", "龍" ].includes(t.type)) safetyScore -= kingThreatPenalty; } if (playerKingPos.r === 7 && playerKingPos.c === 8 && currentBoard[8]?.[8]?.type === "香" && currentBoard[8]?.[7]?.type === "桂" && currentBoard[8]?.[6]?.type === "銀" && currentBoard[7]?.[7]?.type === "金" && currentBoard[6]?.[8]?.type === "歩") safetyScore += 150; score -= safetyScore; } const checkBonus = 80; if (isCheck("player", currentBoard)) score += checkBonus; if (isCheck("enemy", currentBoard)) score -= checkBonus; const turnBonus = 10; if (playerForTurnBonus === "enemy") score += turnBonus; else score -= turnBonus; log(2, `[evaluatePosition] Final score: ${score}`); return score; } function minimax(depth, alpha, beta, isMaximizingPlayer, currentBoard, currentPHand, currentEHand) { const player = isMaximizingPlayer ? "enemy" : "player"; const opponent = isMaximizingPlayer ? "player" : "enemy"; let initialDepth = 2; if (aiDifficulty === "easy") initialDepth = 1; else if (aiDifficulty === "hard") initialDepth = 3; const indent = " ".repeat(initialDepth - depth); log(2, `${indent}[minimax] Depth: ${depth}, Player: ${player}, Alpha: ${alpha}, Beta: ${beta}`); if (isCheckmate(player, currentBoard, currentPHand, currentEHand)) { const score = isMaximizingPlayer ? -Infinity : Infinity; log(2, `${indent}[minimax] Terminal: ${player} is checkmated. Score: ${score}`); return score; } if (isCheckmate(opponent, currentBoard, currentPHand, currentEHand)) { const score = isMaximizingPlayer ? Infinity : -Infinity; log(2, `${indent}[minimax] Terminal: ${opponent} is checkmated. Score: ${score}`); return score; } const possibleMoves = getAllPossibleMoves(player, currentBoard, currentPHand, currentEHand); if (depth === 0 || possibleMoves.length === 0) { const score = evaluatePosition(currentBoard, currentPHand, currentEHand, player); log(2, `${indent}[minimax] Base case (Depth ${depth}, Moves ${possibleMoves.length}). Score: ${score}`); return score; } if (isMaximizingPlayer) { let maxEval = -Infinity; for (const move of possibleMoves){ log(2, `${indent} Evaluating Max Move:`, moveToString(move)); const { board: nextBoard, playerHand: nextPHand, enemyHand: nextEHand } = makeMoveSimulation(move, player, currentBoard, currentPHand, currentEHand); const evalScore = minimax(depth - 1, alpha, beta, false, nextBoard, nextPHand, nextEHand); log(2, `${indent} Move Score: ${evalScore}`); maxEval = Math.max(maxEval, evalScore); alpha = Math.max(alpha, evalScore); if (beta <= alpha) { log(2, `${indent} Beta cutoff: (Beta: ${beta} <= Alpha: ${alpha})`); break; } } log(2, `${indent}[minimax] Returning Max Eval: ${maxEval}`); return maxEval; } else { let minEval = Infinity; for (const move of possibleMoves){ log(2, `${indent} Evaluating Min Move:`, moveToString(move)); const { board: nextBoard, playerHand: nextPHand, enemyHand: nextEHand } = makeMoveSimulation(move, player, currentBoard, currentPHand, currentEHand); const evalScore = minimax(depth - 1, alpha, beta, true, nextBoard, nextPHand, nextEHand); log(2, `${indent} Move Score: ${evalScore}`); minEval = Math.min(minEval, evalScore); beta = Math.min(beta, evalScore); if (beta <= alpha) { log(2, `${indent} Alpha cutoff: (Beta: ${beta} <= Alpha: ${alpha})`); break; } } log(2, `${indent}[minimax] Returning Min Eval: ${minEval}`); return minEval; } } function findBestMove() { log(1, "[findBestMove] Starting AI move search..."); const possibleMoves = getAllPossibleMoves("enemy", board, playerHand, enemyHand); if (possibleMoves.length === 0) { log(1, "[findBestMove] No possible moves found for AI."); return null; } let depth; switch(aiDifficulty){ case "easy": depth = 1; break; case "medium": default: depth = 2; break; case "hard": depth = 3; break; } depth = Math.max(1, depth); log(1, `[findBestMove] Search Depth: ${depth}, Initial Possible Moves: ${possibleMoves.length}`); let bestScore = -Infinity; let bestMoves = []; const startTime = performance.now(); for(let i = 0; i < possibleMoves.length; i++){ const move = possibleMoves[i]; log(1, `[findBestMove] Evaluating move ${i + 1}/${possibleMoves.length}: ${moveToString(move)}`); const { board: nextBoard, playerHand: nextPHand, enemyHand: nextEHand } = makeMoveSimulation(move, "enemy", board, playerHand, enemyHand); const score = minimax(depth - 1, -Infinity, Infinity, false, nextBoard, nextPHand, nextEHand); log(1, `[findBestMove] Move: ${moveToString(move)}, Score: ${score}`); if (score > bestScore) { bestScore = score; bestMoves = [ move ]; log(1, ` New best score found: ${bestScore}`); } else if (score === bestScore) { bestMoves.push(move); log(1, ` Score matches best score. Adding to best moves list (${bestMoves.length} total).`); } } const endTime = performance.now(); log(1, `[findBestMove] Search finished in ${(endTime - startTime).toFixed(2)} ms.`); if (bestMoves.length === 0) { console.warn("[findBestMove] No best move identified, returning random move."); return possibleMoves[Math.floor(Math.random() * possibleMoves.length)]; } const selectedMove = bestMoves[Math.floor(Math.random() * bestMoves.length)]; log(1, `[findBestMove] Chose move: ${moveToString(selectedMove)} from ${bestMoves.length} best options with score: ${bestScore}`); return selectedMove; } // ============================================================ // 状態更新 & ゲーム進行ロジック (useCallback を維持) // ============================================================ const updateMoveHistory = useCallback((moveData)=>{ const playerSymbol = moveData.player === "player" ? "△" : "▲"; const notationString = moveToString(moveData); setMoveHistory((prev)=>[ { ...moveData, notation: `${playerSymbol} ${notationString}` }, ...prev ]); }, []); const updateGameStatus = useCallback((newStatus)=>{ setGameStatus(newStatus); }, []); const capturePiece = useCallback((capturedPiece, capturingPlayer)=>{ if (!capturedPiece) return; let originalType = capturedPiece.originalType; if (!initialPieceTypesForHand.includes(originalType)) return; const targetHandSetter = capturingPlayer === "player" ? setPlayerHand : setEnemyHand; targetHandSetter((prevHand)=>{ log(2, `[capturePiece] Adding ${originalType} to ${capturingPlayer} hand. Prev:`, prevHand); const newHand = { ...prevHand, [originalType]: (prevHand[originalType] || 0) + 1 }; log(2, `[capturePiece] New hand state:`, newHand); return newHand; }); }, [ log ]); const completeMovePiece = useCallback((moveDetails)=>{ const { didPromote, finalPieceState, fromRow, fromCol, toRow, toCol, capturedPieceOriginal } = moveDetails; log(1, `[completeMovePiece] Player move completed. ${fromRow},${fromCol} -> ${toRow},${toCol}. Promoting: ${didPromote}, Piece: ${finalPieceState?.type ?? "N/A"}`); if (typeof fromRow !== "number" || typeof fromCol !== "number" || typeof toRow !== "number" || typeof toCol !== "number" || !finalPieceState) { console.error("[completeMovePiece Error] Invalid move details received:", moveDetails); setGameOver(true); updateGameStatus("エラーが発生しました (Move Completion)"); return; } const newBoard = board.map((r)=>r.map((p)=>p ? { ...p } : null)); const checkmateCheckPHand = { ...playerHand }; const checkmateCheckEHand = enemyHand; let nextPHandForCheck = { ...checkmateCheckPHand }; if (capturedPieceOriginal) { if (initialPieceTypesForHand.includes(capturedPieceOriginal)) nextPHandForCheck[capturedPieceOriginal] = (nextPHandForCheck[capturedPieceOriginal] || 0) + 1; } if (capturedPieceOriginal) capturePiece({ originalType: capturedPieceOriginal }, "player"); newBoard[toRow][toCol] = finalPieceState; newBoard[fromRow][fromCol] = null; log(1, "[completeMovePiece] Updating board state:", newBoard); setBoard(newBoard); const moveData = { piece: finalPieceState.originalType, promotedType: didPromote ? finalPieceState.type : null, from: { row: fromRow, col: fromCol }, to: { row: toRow, col: toCol }, isCapture: !!capturedPieceOriginal, capturedPiece: capturedPieceOriginal, isPromotion: didPromote, player: "player" }; updateMoveHistory(moveData); setSelectedPiece(null); setSelectedCell(null); const isMate = isCheckmate("enemy", newBoard, nextPHandForCheck, checkmateCheckEHand); log(1, `[completeMovePiece] Checked opponent mate after move: ${isMate}`); if (isMate) { setGameOver(true); updateGameStatus("あなたの勝ちです！"); return; } log(1, `[completeMovePiece] Switching to enemy turn.`); setCurrentPlayer("enemy"); updateGameStatus("AI の番です"); }, [ board, playerHand, enemyHand, capturePiece, updateMoveHistory, updateGameStatus, log ]); const handlePromotionChoice = useCallback((promote)=>{ setShowPromotionModal(false); if (promotionArgs) { const { piece, fromRow, fromCol, toRow, toCol, capturedPieceOriginal, finalCallback } = promotionArgs; let finalPieceState = piece; if (promote) { finalPieceState = getPromotedPiece(piece); } const moveDetails = { didPromote: promote, finalPieceState, fromRow, fromCol, toRow, toCol, capturedPieceOriginal }; log(1, "[handlePromotionChoice] Calling finalCallback with:", moveDetails); finalCallback(moveDetails); } else { console.error("Promotion choice made but no move arguments found."); } setPromotionArgs(null); }, [ promotionArgs, log ]); const checkPromotion = useCallback((piece, fromRow, fromCol, toRow, toCol, capturedPieceOriginal, finalCallback)=>{ log(2, `[checkPromotion] Checking promotion for ${piece.type} moving from (${fromRow},${fromCol}) to (${toRow},${toCol})`); const moveDetailsBase = { fromRow, fromCol, toRow, toCol, capturedPieceOriginal }; if (piece.type !== piece.originalType || [ "金", "王", "玉" ].includes(piece.originalType)) { finalCallback({ ...moveDetailsBase, didPromote: false, finalPieceState: piece }); return; } const isPromotableType = promotableOriginalTypes.includes(piece.originalType); const mustPromoteMove = mustPromote(piece, toRow); if (isPromotableType && mustPromoteMove) { const promotedPiece = getPromotedPiece(piece); finalCallback({ ...moveDetailsBase, didPromote: true, finalPieceState: promotedPiece }); return; } const isEnteringZone = piece.owner === "player" ? toRow <= 2 : toRow >= 6; const isStartingInZone = piece.owner === "player" ? fromRow <= 2 : fromRow >= 6; if (isPromotableType && (isEnteringZone || isStartingInZone)) { if (piece.owner === "player") { log(1, `[checkPromotion] Showing promotion modal for player.`); setPromotionArgs({ piece, ...moveDetailsBase, finalCallback }); setShowPromotionModal(true); } else { const shouldPromote = shouldAIPromote(piece, toRow); const finalPieceState = shouldPromote ? getPromotedPiece(piece) : piece; finalCallback({ ...moveDetailsBase, didPromote: shouldPromote, finalPieceState: finalPieceState }); } } else { finalCallback({ ...moveDetailsBase, didPromote: false, finalPieceState: piece }); } }, [ log ]); const dropPiece = useCallback((type, row, col)=>{ log(1, `[dropPiece] Player dropping ${type} at (${row}, ${col})`); const checkmateCheckPHand = { ...playerHand }; const checkmateCheckEHand = enemyHand; checkmateCheckPHand[type] = Math.max(0, (checkmateCheckPHand[type] || 0) - 1); setPlayerHand((prevHand)=>({ ...prevHand, [type]: Math.max(0, (prevHand[type] || 0) - 1) })); const newBoard = board.map((r)=>r.map((p)=>p ? { ...p } : null)); newBoard[row][col] = { type: type, owner: "player", originalType: type }; log(1, "[dropPiece] Updating board state:", newBoard); setBoard(newBoard); const moveData = { piece: type, from: { isHand: true }, to: { row, col }, isCapture: false, capturedPiece: null, isPromotion: false, promotedType: null, player: "player" }; updateMoveHistory(moveData); setSelectedPiece(null); setSelectedCell(null); const isMate = isCheckmate("enemy", newBoard, checkmateCheckPHand, checkmateCheckEHand); log(1, `[dropPiece] Checked opponent mate after drop: ${isMate}`); if (isMate) { setGameOver(true); updateGameStatus("あなたの勝ちです！"); return; } log(1, `[dropPiece] Switching to enemy turn.`); setCurrentPlayer("enemy"); updateGameStatus("AI の番です"); }, [ board, playerHand, enemyHand, updateMoveHistory, updateGameStatus, log ]); const movePiece = useCallback((fromRow, fromCol, toRow, toCol)=>{ log(1, `[movePiece] Player attempting move from (${fromRow},${fromCol}) to (${toRow},${toCol})`); const pieceToMove = board[fromRow]?.[fromCol]; if (!pieceToMove) { log(1, "[movePiece Error] No piece to move."); return; } const targetPiece = board[toRow]?.[toCol]; checkPromotion(pieceToMove, fromRow, fromCol, toRow, toCol, targetPiece?.originalType, completeMovePiece); }, [ board, checkPromotion, completeMovePiece, log ]); const executeAiMove = useCallback((aiMove)=>{ log(1, `[executeAiMove] Executing AI move:`, aiMove ? moveToString(aiMove) : "null"); if (!aiMove) { log(1, `[executeAiMove] AI move is null (no possible moves). Checking if AI is mated...`); if (isCheckmate("enemy", board, playerHand, enemyHand)) { setGameOver(true); updateGameStatus("あなたの勝ちです！（AIの手がありません）"); } else { updateGameStatus("引き分け？（AIの手がありません）"); setGameOver(true); } setThinking(false); return; } const { piece, from, to, isPromotion } = aiMove; const newBoard = board.map((r)=>r.map((p)=>p ? { ...p } : null)); let finalPieceState; const checkmateCheckPHand = playerHand; let checkmateCheckEHand = { ...enemyHand }; if (from.isHand) { log(2, ` AI Drop: ${piece} to (${to.row}, ${to.col})`); checkmateCheckEHand[piece] = Math.max(0, (checkmateCheckEHand[piece] || 0) - 1); setEnemyHand((prevHand)=>({ ...prevHand, [piece]: Math.max(0, (prevHand[piece] || 0) - 1) })); finalPieceState = { type: piece, owner: "enemy", originalType: piece }; newBoard[to.row][to.col] = finalPieceState; } else { log(2, ` AI Move: ${piece} from (${from.row},${from.col}) to (${to.row}, ${to.col}), Promotion: ${isPromotion}`); const pieceToMove = { ...newBoard[from.row]?.[from.col] }; if (!pieceToMove || pieceToMove.owner !== "enemy") { console.error("[AI Execute Error] Invalid piece", aiMove); setThinking(false); return; } const targetPiece = newBoard[to.row]?.[to.col]; if (targetPiece) { log(2, ` Capturing ${targetPiece.originalType}`); if (initialPieceTypesForHand.includes(targetPiece.originalType)) checkmateCheckEHand[targetPiece.originalType] = (checkmateCheckEHand[targetPiece.originalType] || 0) + 1; capturePiece(targetPiece, "enemy"); } newBoard[from.row][from.col] = null; if (isPromotion) finalPieceState = getPromotedPiece(pieceToMove); else finalPieceState = pieceToMove; newBoard[to.row][to.col] = finalPieceState; } log(1, "[executeAiMove] Updating board state:", newBoard); setBoard(newBoard); const moveData = { ...aiMove, player: "enemy" }; updateMoveHistory(moveData); const isMate = isCheckmate("player", newBoard, checkmateCheckPHand, checkmateCheckEHand); log(1, `[executeAiMove] Checked player mate after AI move: ${isMate}`); if (isMate) { setGameOver(true); updateGameStatus("AI の勝ちです！"); } else { log(1, `[executeAiMove] Switching to player turn.`); setCurrentPlayer("player"); updateGameStatus("あなたの番です"); } setThinking(false); log(1, `[executeAiMove] Finished AI move execution.`); }, [ board, playerHand, enemyHand, capturePiece, updateMoveHistory, updateGameStatus, log, moveToString, getPromotedPiece ]); const initializeBoard = useCallback(()=>{ log(1, "[initializeBoard] Initializing board and hands..."); const newBoard = Array.from({ length: 9 }).fill().map(()=>Array.from({ length: 9 }).fill(null)); newBoard[0][0] = { type: "香", owner: "enemy", originalType: "香" }; newBoard[0][1] = { type: "桂", owner: "enemy", originalType: "桂" }; newBoard[0][2] = { type: "銀", owner: "enemy", originalType: "銀" }; newBoard[0][3] = { type: "金", owner: "enemy", originalType: "金" }; newBoard[0][4] = { type: "王", owner: "enemy", originalType: "王" }; newBoard[0][5] = { type: "金", owner: "enemy", originalType: "金" }; newBoard[0][6] = { type: "銀", owner: "enemy", originalType: "銀" }; newBoard[0][7] = { type: "桂", owner: "enemy", originalType: "桂" }; newBoard[0][8] = { type: "香", owner: "enemy", originalType: "香" }; newBoard[1][1] = { type: "飛", owner: "enemy", originalType: "飛" }; newBoard[1][7] = { type: "角", owner: "enemy", originalType: "角" }; for(let c = 0; c < 9; c++)newBoard[2][c] = { type: "歩", owner: "enemy", originalType: "歩" }; for(let c = 0; c < 9; c++)newBoard[6][c] = { type: "歩", owner: "player", originalType: "歩" }; newBoard[7][1] = { type: "角", owner: "player", originalType: "角" }; newBoard[7][7] = { type: "飛", owner: "player", originalType: "飛" }; newBoard[8][0] = { type: "香", owner: "player", originalType: "香" }; newBoard[8][1] = { type: "桂", owner: "player", originalType: "桂" }; newBoard[8][2] = { type: "銀", owner: "player", originalType: "銀" }; newBoard[8][3] = { type: "金", owner: "player", originalType: "金" }; newBoard[8][4] = { type: "玉", owner: "player", originalType: "玉" }; newBoard[8][5] = { type: "金", owner: "player", originalType: "金" }; newBoard[8][6] = { type: "銀", owner: "player", originalType: "銀" }; newBoard[8][7] = { type: "桂", owner: "player", originalType: "桂" }; newBoard[8][8] = { type: "香", owner: "player", originalType: "香" }; log(1, "[initializeBoard] Setting initial board state:", newBoard); setBoard(newBoard); const resetHand = {}; initialPieceTypesForHand.forEach((t)=>{ resetHand[t] = 0; }); log(1, "[initializeBoard] Setting initial hand states:", resetHand, resetHand); setPlayerHand(resetHand); setEnemyHand(resetHand); log(1, "[initializeBoard] Initialization complete."); }, [ log ]); const resetGame = useCallback(()=>{ log(1, "[resetGame] Resetting game..."); if (aiThinkTimeoutRef.current) clearTimeout(aiThinkTimeoutRef.current); initializeBoard(); setCurrentPlayer("player"); setSelectedPiece(null); setSelectedCell(null); setMoveHistory([]); setGameOver(false); setGameStatus("あなたの番です（先手）"); setThinking(false); setShowPromotionModal(false); setPromotionArgs(null); log(1, "[resetGame] Game reset complete."); }, [ initializeBoard, log ]); // ============================================================ // プレイヤー操作ハンドラ // ============================================================ const handleCellClick = useCallback((row, col)=>{ log(1, `[handleCellClick] Clicked cell (${row}, ${col}). CurrentPlayer: ${currentPlayer}, Thinking: ${thinking}, Selected:`, selectedPiece ? selectedPiece.isInHand ? selectedPiece.type + " (hand)" : selectedPiece.type + " (board)" : "none"); if (gameOver || currentPlayer !== "player" || thinking) return; const clickedPiece = board[row]?.[col]; if (selectedPiece) { if (selectedPiece.isInHand) { log(2, ` Attempting to drop ${selectedPiece.type}`); const isValidDropTarget = getValidDropPositionsForBoard(board, selectedPiece.type, "player").some((p)=>p.row === row && p.col === col); const { board: nextBoard, playerHand: nextPHand } = makeMoveSimulation({ piece: selectedPiece.type, from: { isHand: true }, to: { row, col } }, "player", board, playerHand, enemyHand); const isSelfCheck = isCheck("player", nextBoard); const isIllegalPawnDrop = selectedPiece.type === "歩" && isPawnDropMateForBoard(nextBoard, "player", row, col, nextPHand, enemyHand); const isLegal = isValidDropTarget && !isSelfCheck && !isIllegalPawnDrop; log(2, ` Drop Legality - ValidTarget: ${isValidDropTarget}, Not Self-Check: ${!isSelfCheck}, Not PawnDropMate: ${!isIllegalPawnDrop}`); if (isLegal) dropPiece(selectedPiece.type, row, col); else { setSelectedPiece(null); setSelectedCell(null); if (!isValidDropTarget) {} else if (isSelfCheck) alert("この場所に駒を打つと王様が取られてしまいます。"); else if (isIllegalPawnDrop) alert("打ち歩詰めは反則です。"); else alert("不正な打ち場所です。"); } } else { log(2, ` Attempting to move ${selectedPiece.type} from (${selectedCell?.row ?? "?"},${selectedCell?.col ?? "?"}) to (${row},${col})`); if (clickedPiece && clickedPiece.owner === "player" && !(selectedCell.row === row && selectedCell.col === col)) { log(2, ` Switching selection to ${clickedPiece.type}`); setSelectedPiece({ ...clickedPiece, isInHand: false }); setSelectedCell({ row, col }); } else if (selectedCell && !(selectedCell.row === row && selectedCell.col === col)) { const validMoves = getValidMovesForBoard(board, selectedCell.row, selectedCell.col); const isValidTarget = validMoves.some((m)=>m.row === row && m.col === col); const { board: nextBoard } = makeMoveSimulation({ piece: selectedPiece.originalType, from: { row: selectedCell.row, col: selectedCell.col }, to: { row, col }, isCapture: !!clickedPiece, isPromotion: false }, "player", board, playerHand, enemyHand); const isSelfCheck = isCheck("player", nextBoard); const isLegal = isValidTarget && !isSelfCheck; log(2, ` Move Legality - ValidTarget: ${isValidTarget}, Not Self-Check: ${!isSelfCheck}`); if (isLegal) { movePiece(selectedCell.row, selectedCell.col, row, col); } else { setSelectedPiece(null); setSelectedCell(null); if (!isValidTarget) {} else alert("この移動は反則になります（王様が取られるなど）。"); } } else if (selectedCell && selectedCell.row === row && selectedCell.col === col) { log(2, ` Clicked same cell, deselecting.`); setSelectedPiece(null); setSelectedCell(null); } else { log(1, `[handleCellClick] Unexpected state when moving piece. Deselecting.`); setSelectedPiece(null); setSelectedCell(null); } } } else if (clickedPiece && clickedPiece.owner === "player") { log(2, ` Selecting board piece ${clickedPiece.type} at (${row}, ${col})`); setSelectedPiece({ ...clickedPiece, isInHand: false }); setSelectedCell({ row, col }); } else { log(2, ` Clicked empty cell or opponent piece with no selection.`); } }, [ gameOver, currentPlayer, thinking, board, selectedPiece, selectedCell, playerHand, enemyHand, dropPiece, movePiece, log ]); const handleHandPieceClick = useCallback((type)=>{ log(1, `[handleHandPieceClick] Clicked hand piece ${type}. CurrentPlayer: ${currentPlayer}, Thinking: ${thinking}, Selected:`, selectedPiece ? selectedPiece.isInHand ? selectedPiece.type + " (hand)" : selectedPiece.type + " (board)" : "none"); if (gameOver || currentPlayer !== "player" || thinking) return; if (playerHand[type] > 0) { if (selectedPiece && selectedPiece.isInHand && selectedPiece.type === type) { log(2, ` Deselecting hand piece ${type}.`); setSelectedPiece(null); setSelectedCell(null); } else { log(2, ` Selecting hand piece ${type}.`); setSelectedPiece({ type: type, owner: "player", isInHand: true }); setSelectedCell(null); } } else { log(2, ` Clicked hand piece ${type}, but count is 0.`); } }, [ gameOver, currentPlayer, thinking, playerHand, selectedPiece, log ]); const handleDifficultyChange = useCallback((event)=>{ log(1, `[handleDifficultyChange] Difficulty changed to ${event.target.value}`); setAiDifficulty(event.target.value); }, [ log ]); // ============================================================ // useEffect フック // ============================================================ useEffect(()=>{ resetGame(); // eslint-disable-next-line react-hooks/exhaustive-deps }, []); useEffect(()=>{ log(1, `[useEffect AI Turn Check] CurrentPlayer: ${currentPlayer}, GameOver: ${gameOver}, Thinking: ${thinking}`); let timeoutId = null; if (currentPlayer === "enemy" && !gameOver) { if (!thinking) { log(1, ` AI turn detected. Starting timeout to begin thinking...`); timeoutId = setTimeout(()=>{ log(1, `[setTimeout AI Callback] Setting thinking=true & starting AI move calculation...`); setThinking(true); try { const bestMove = findBestMove(); if (!gameOver) { const aiMoves = getAllPossibleMoves("enemy", board, playerHand, enemyHand); if (aiMoves.length > 0) { if (bestMove) { executeAiMove(bestMove); } else { console.error("[AI Timeout Error] findBestMove returned null but moves exist!", aiMoves); log(1, " Fallback: Executing random move."); executeAiMove(aiMoves[Math.floor(Math.random() * aiMoves.length)]); } } else { log(1, ` AI has no moves. Checking mate/stalemate.`); if (isCheckmate("enemy", board, playerHand, enemyHand)) { setGameOver(true); updateGameStatus("あなたの勝ちです！（AIの手がありません）"); } else { setGameOver(true); updateGameStatus("引き分け？（AIの手がありません）"); } setThinking(false); } } else { log(1, `[setTimeout AI Callback] Game ended while thinking. Aborting AI move execution.`); setThinking(false); } } catch (error) { console.error("[AI Timeout Error] Error during AI move calculation/execution:", error); setGameOver(true); updateGameStatus("エラーが発生しました。"); setThinking(false); } }, 100); aiThinkTimeoutRef.current = timeoutId; } else { log(1, ` AI turn, but already thinking.`); } } else if (currentPlayer === "player" && thinking) { log(1, `[useEffect AI Turn] Not AI turn but thinking=true. Resetting thinking state.`); setThinking(false); if (aiThinkTimeoutRef.current) { clearTimeout(aiThinkTimeoutRef.current); aiThinkTimeoutRef.current = null; } } return ()=>{ if (timeoutId) { log(1, `[useEffect AI Cleanup] Clearing timeout ID: ${timeoutId}`); clearTimeout(timeoutId); if (aiThinkTimeoutRef.current === timeoutId) { aiThinkTimeoutRef.current = null; } } }; }, [ currentPlayer, gameOver, board, playerHand, enemyHand, executeAiMove, updateGameStatus, log ]); // thinking 依存削除 // ============================================================ // レンダリング (JSX) // ============================================================ return /*#__PURE__*/ React.createElement("div", { style: { fontFamily: "'Noto Sans JP', sans-serif", display: "flex", flexDirection: "column", alignItems: "center", backgroundColor: "beige", color: "#333", margin: 0, padding: "20px" }, __source: { fileName: "", lineNumber: 1897, columnNumber: 5 }, __self: this }, /*#__PURE__*/ React.createElement("h1", { style: { marginBottom: "10px", color: "#8b4513" }, __source: { fileName: "", lineNumber: 1909, columnNumber: 7 }, __self: this }, "将棋ゲーム Create.xyz"), /*#__PURE__*/ React.createElement("div", { style: { margin: "20px 0", padding: "10px", border: "1px solid #8b4513", borderRadius: "5px", backgroundColor: "#fff", width: "100%", maxWidth: "600px", textAlign: "center" }, __source: { fileName: "", lineNumber: 1912, columnNumber: 7 }, __self: this }, /*#__PURE__*/ React.createElement("div", { style: { fontWeight: 700, fontSize: "1.2em", marginBottom: "10px" }, __source: { fileName: "", lineNumber: 1924, columnNumber: 9 }, __self: this }, gameStatus), thinking && /*#__PURE__*/ React.createElement("div", { style: { marginTop: "10px", fontStyle: "italic", color: "#666" }, __source: { fileName: "", lineNumber: 1930, columnNumber: 11 }, __self: this }, "AIが考え中..."), /*#__PURE__*/ React.createElement("div", { style: { marginTop: "10px", display: "flex", gap: "10px", alignItems: "center", justifyContent: "center" }, __source: { fileName: "", lineNumber: 1936, columnNumber: 9 }, __self: this }, /*#__PURE__*/ React.createElement("label", { htmlFor: "difficulty", __source: { fileName: "", lineNumber: 1945, columnNumber: 11 }, __self: this }, "AI難易度:"), /*#__PURE__*/ React.createElement("select", { id: "difficulty", value: aiDifficulty, onChange: handleDifficultyChange, disabled: thinking || gameOver, style: { padding: "5px", borderRadius: "4px", border: "1px solid #8b4513" }, __source: { fileName: "", lineNumber: 1946, columnNumber: 11 }, __self: this }, /*#__PURE__*/ React.createElement("option", { value: "easy", __source: { fileName: "", lineNumber: 1957, columnNumber: 13 }, __self: this }, "初級 (1手)"), /*#__PURE__*/ React.createElement("option", { value: "medium", __source: { fileName: "", lineNumber: 1958, columnNumber: 13 }, __self: this }, "中級 (2手)"), /*#__PURE__*/ React.createElement("option", { value: "hard", __source: { fileName: "", lineNumber: 1959, columnNumber: 13 }, __self: this }, "上級 (3手)")))), /*#__PURE__*/ React.createElement("div", { style: { display: "flex", flexWrap: "wrap", justifyContent: "center", gap: "20px", marginTop: "20px" }, __source: { fileName: "", lineNumber: 1963, columnNumber: 7 }, __self: this }, /*#__PURE__*/ React.createElement("div", { style: { display: "flex", flexDirection: "column", margin: "10px", minWidth: "180px" }, __source: { fileName: "", lineNumber: 1972, columnNumber: 9 }, __self: this }, /*#__PURE__*/ React.createElement("h3", { __source: { fileName: "", lineNumber: 1980, columnNumber: 11 }, __self: this }, "AI の持ち駒"), /*#__PURE__*/ React.createElement("div", { style: { display: "flex", flexWrap: "wrap", gap: "5px", marginBottom: "15px", padding: "10px", border: "1px solid #8b4513", backgroundColor: "#d8bfd8", borderRadius: "5px", minHeight: "120px" }, __source: { fileName: "", lineNumber: 1981, columnNumber: 11 }, __self: this }, Object.entries(enemyHand).sort(([typeA], [typeB])=>initialPieceTypesForHand.indexOf(typeA) - initialPieceTypesForHand.indexOf(typeB)).map(([type, count])=>count > 0 && /*#__PURE__*/ React.createElement("div", { key: type, style: { width: "40px", height: "40px", margin: "2px", fontSize: "20px", fontWeight: 700, display: "flex", justifyContent: "center", alignItems: "center", borderRadius: "50%", backgroundColor: "#d8bfd8", position: "relative", transform: "rotate(180deg)" }, __source: { fileName: "", lineNumber: 2003, columnNumber: 21 }, __self: this }, " ", type, " ", count > 1 && /*#__PURE__*/ React.createElement("div", { style: { position: "absolute", bottom: "-5px", right: "-5px", backgroundColor: "#fff", borderRadius: "50%", width: "18px", height: "18px", fontSize: "12px", display: "flex", justifyContent: "center", alignItems: "center", border: "1px solid #8b4513", transform: "rotate(-180deg)" }, __source: { fileName: "", lineNumber: 2023, columnNumber: 25 }, __self: this }, count), " ")))), /*#__PURE__*/ React.createElement("div", { style: { position: "relative" }, __source: { fileName: "", lineNumber: 2048, columnNumber: 9 }, __self: this }, /*#__PURE__*/ React.createElement("div", { style: { display: "grid", gridTemplateColumns: "repeat(9, 60px)", gridTemplateRows: "repeat(9, 60px)", border: "2px solid #8b4513", backgroundColor: "#debb87" }, __source: { fileName: "", lineNumber: 2049, columnNumber: 11 }, __self: this }, board.map((rowItems, r)=>rowItems.map((pieceData, c)=>/*#__PURE__*/ React.createElement("div", { key: `${r}-${c}`, className: "cell", onClick: ()=>handleCellClick(r, c), style: { width: "60px", height: "60px", border: "1px solid #8b4513", display: "flex", justifyContent: "center", alignItems: "center", position: "relative", cursor: gameOver || currentPlayer !== "player" || thinking ? "default" : "pointer", fontSize: "28px", fontWeight: 700 }, __source: { fileName: "", lineNumber: 2060, columnNumber: 17 }, __self: this }, " ", c === 0 && /*#__PURE__*/ React.createElement("div", { style: { position: "absolute", fontSize: "14px", color: "#8b4513", fontWeight: 700, left: "-25px", top: "50%", transform: "translateY(-50%)" }, __source: { fileName: "", lineNumber: 2082, columnNumber: 21 }, __self: this }, r + 1), " ", r === 0 && /*#__PURE__*/ React.createElement("div", { style: { position: "absolute", fontSize: "14px", color: "#8b4513", fontWeight: 700, top: "-25px", left: "50%", transform: "translateX(-50%)" }, __source: { fileName: "", lineNumber: 2097, columnNumber: 21 }, __self: this }, 9 - c), " ", /*#__PURE__*/ React.createElement("div", { style: { display: "flex", justifyContent: "center", alignItems: "center", width: "54px", height: "54px", borderRadius: "50%" }, __source: { fileName: "", lineNumber: 2111, columnNumber: 19 }, __self: this }, " ", pieceData && /*#__PURE__*/ React.createElement("div", { className: `piece ${pieceData.owner}`, style: { width: "54px", height: "54px", position: "relative", display: "flex", justifyContent: "center", alignItems: "center", transition: "all .2s", backgroundColor: pieceData.owner === "enemy" ? "#d8bfd8" : "#e6bc65", borderRadius: "50%", boxShadow: "0 3px 3px rgba(0,0,0,.2)", transform: pieceData.owner === "enemy" ? "rotate(180deg)" : "none", ...selectedCell && selectedCell.row === r && selectedCell.col === c && !selectedPiece?.isInHand && { backgroundColor: "khaki", boxShadow: "0 0 5px 3px rgba(255,215,0,.7)" } }, __source: { fileName: "", lineNumber: 2123, columnNumber: 23 }, __self: this }, " ", pieceData.type, " "), " "), " "))))), /*#__PURE__*/ React.createElement("div", { style: { display: "flex", flexDirection: "column", margin: "10px", minWidth: "180px" }, __source: { fileName: "", lineNumber: 2160, columnNumber: 9 }, __self: this }, /*#__PURE__*/ React.createElement("h3", { __source: { fileName: "", lineNumber: 2168, columnNumber: 11 }, __self: this }, "あなたの持ち駒"), /*#__PURE__*/ React.createElement("div", { style: { display: "flex", flexWrap: "wrap", gap: "5px", marginBottom: "15px", padding: "10px", border: "1px solid #8b4513", backgroundColor: "#e6bc65", borderRadius: "5px", minHeight: "120px" }, __source: { fileName: "", lineNumber: 2169, columnNumber: 11 }, __self: this }, Object.entries(playerHand).sort(([typeA], [typeB])=>initialPieceTypesForHand.indexOf(typeA) - initialPieceTypesForHand.indexOf(typeB)).map(([type, count])=>count > 0 && /*#__PURE__*/ React.createElement("div", { key: type, onClick: ()=>handleHandPieceClick(type), style: { width: "40px", height: "40px", margin: "2px", fontSize: "20px", fontWeight: 700, cursor: gameOver || currentPlayer !== "player" || thinking || playerHand[type] === 0 ? "default" : "pointer", display: "flex", justifyContent: "center", alignItems: "center", borderRadius: "50%", backgroundColor: "#e6bc65", position: "relative", ...selectedPiece && selectedPiece.isInHand && selectedPiece.type === type && { backgroundColor: "khaki", boxShadow: "0 0 5px 3px rgba(255,215,0,.7)" } }, __source: { fileName: "", lineNumber: 2191, columnNumber: 21 }, __self: this }, " ", type, " ", count > 1 && /*#__PURE__*/ React.createElement("div", { style: { position: "absolute", bottom: "-5px", right: "-5px", backgroundColor: "#fff", borderRadius: "50%", width: "18px", height: "18px", fontSize: "12px", display: "flex", justifyContent: "center", alignItems: "center", border: "1px solid #8b4513" }, __source: { fileName: "", lineNumber: 2224, columnNumber: 25 }, __self: this }, count), " "))))), /*#__PURE__*/ React.createElement("div", { style: { marginTop: "20px", padding: "10px", border: "1px solid #8b4513", borderRadius: "5px", backgroundColor: "#fff", width: "100%", maxWidth: "600px", maxHeight: "200px", overflowY: "auto" }, __source: { fileName: "", lineNumber: 2249, columnNumber: 7 }, __self: this }, /*#__PURE__*/ React.createElement("h3", { style: { marginTop: 0, textAlign: "center" }, __source: { fileName: "", lineNumber: 2262, columnNumber: 9 }, __self: this }, "棋譜"), /*#__PURE__*/ React.createElement("div", { style: { display: "flex", flexDirection: "column-reverse", gap: "5px" }, __source: { fileName: "", lineNumber: 2263, columnNumber: 9 }, __self: this }, moveHistory.map((move, index)=>/*#__PURE__*/ React.createElement("div", { key: moveHistory.length - 1 - index, style: { padding: "5px", borderBottom: index === moveHistory.length - 1 ? "none" : "1px solid #ddd", display: "flex", justifyContent: "space-between" }, __source: { fileName: "", lineNumber: 2271, columnNumber: 13 }, __self: this }, " ", /*#__PURE__*/ React.createElement("span", { __source: { fileName: "", lineNumber: 2282, columnNumber: 15 }, __self: this }, moveHistory.length - index, ". ", move.notation), " ")))), showPromotionModal && /*#__PURE__*/ React.createElement("div", { style: { position: "fixed", top: 0, left: 0, width: "100%", height: "100%", backgroundColor: "rgba(0,0,0,.5)", display: "flex", justifyContent: "center", alignItems: "center", zIndex: 10 }, __source: { fileName: "", lineNumber: 2290, columnNumber: 9 }, __self: this }, " ", /*#__PURE__*/ React.createElement("div", { style: { backgroundColor: "#fff", padding: "20px", borderRadius: "5px", textAlign: "center" }, __source: { fileName: "", lineNumber: 2305, columnNumber: 11 }, __self: this }, " ", /*#__PURE__*/ React.createElement("h3", { __source: { fileName: "", lineNumber: 2314, columnNumber: 13 }, __self: this }, "駒を成りますか？"), " ", /*#__PURE__*/ React.createElement("div", { style: { marginTop: "20px", display: "flex", justifyContent: "center", gap: "10px" }, __source: { fileName: "", lineNumber: 2315, columnNumber: 13 }, __self: this }, " ", /*#__PURE__*/ React.createElement("button", { onClick: ()=>handlePromotionChoice(true), style: { padding: "10px 15px", border: 0, borderRadius: "5px", backgroundColor: "#8b4513", color: "#fff", cursor: "pointer", fontWeight: 700, transition: "background-color .3s" }, __source: { fileName: "", lineNumber: 2324, columnNumber: 15 }, __self: this }, "はい"), " ", /*#__PURE__*/ React.createElement("button", { onClick: ()=>handlePromotionChoice(false), style: { padding: "10px 15px", border: 0, borderRadius: "5px", backgroundColor: "#8b4513", color: "#fff", cursor: "pointer", fontWeight: 700, transition: "background-color .3s" }, __source: { fileName: "", lineNumber: 2339, columnNumber: 15 }, __self: this }, "いいえ"), " "), " "), " "), /*#__PURE__*/ React.createElement("button", { onClick: resetGame, style: { marginTop: "20px", padding: "10px 15px", border: 0, borderRadius: "5px", backgroundColor: "#8b4513", color: "#fff", cursor: "pointer", fontWeight: 700, transition: "background-color .3s" }, disabled: thinking, __source: { fileName: "", lineNumber: 2358, columnNumber: 7 }, __self: this }, "新しいゲーム")); }