私たちR60のポンコツ夫婦は、アウトドア活動（BIKE日記）とインドア活動のバランスを大切にしています。夫婦仲良く老いていくには、共通のインドア趣味が欠かせません。その中心にあるのが、Fire TV Stickを使ってリビングで楽しむ海外ドラマ鑑賞です。
今回は、私の「アクション・潜入捜査もの」好きと、redkabagonの「謎解きとチームの絆」好き、両方を満たしてくれた傑作、『NCIS: LA ～極秘潜入捜査班』のシーズン3を深く掘り下げます。単なる事件捜査ドラマという枠を超え、シリーズ全体を貫く縦軸のストーリーが、ついに大きな転換期を迎えるシーズンです。
# othello.py
# 1. ゲームボードの初期化
def create_board():
board = []
for i in range(8):
row = [' '] * 8
board.append(row)
board[3][3] = 'W'
board[3][4] = 'B'
board[4][3] = 'B'
board[4][4] = 'W'
return board
# 2. ボードの表示
def print_board(board):
print(' a b c d e f g h')
print(' +-+-+-+-+-+-+-+-+')
for i in range(8):
print(f'{i+1}|', end='')
for j in range(8):
print(f'{board[i][j]}|', end='')
print(f' {i+1}')
print(' +-+-+-+-+-+-+-+-+')
print(' a b c d e f g h')
# 3. 駒を置ける場所の判定と駒の反転
def is_valid_move(board, row, col, player, opponent):
if not (0 <= row < 8 and 0 <= col < 8) or board[row][col] != ' ':
return False
directions = [
(-1, -1), (-1, 0), (-1, 1),
(0, -1), (0, 1),
(1, -1), (1, 0), (1, 1)
]
found_flips = []
for dr, dc in directions:
r, c = row + dr, col + dc
path = []
while 0 <= r < 8 and 0 <= c < 8 and board[r][c] == opponent:
path.append((r, c))
r, c = r + dr, c + dc
if 0 <= r < 8 and 0 <= c < 8 and board[r][c] == player and path:
found_flips.extend(path)
return found_flips
def flip_pieces(board, pieces_to_flip, player):
for r, c in pieces_to_flip:
board[r][c] = player
# 4. メインゲームループ
def main():
board = create_board()
player_turn = 'B'
opponent_turn = 'W'
while True:
print_board(board)
print(f'現在のターン: {player_turn}')
try:
move_str = input('駒を置く場所を入力してください (例: d3): ')
col_char = move_str[0].lower()
row_char = move_str[1:]
# 入力を座標に変換
col = 'abcdefgh'.index(col_char)
row = int(row_char) - 1
if not (0 <= row < 8 and 0 <= col < 8):
print('無効な入力です。')
continue
# 有効な手か判定
pieces_to_flip = is_valid_move(board, row, col, player_turn, opponent_turn)
if pieces_to_flip:
board[row][col] = player_turn
flip_pieces(board, pieces_to_flip, player_turn)
# ターンを交代
player_turn, opponent_turn = opponent_turn, player_turn
else:
print('その場所には置けません。有効な手を打ってください。')
except (ValueError, IndexError):
print('無効な入力です。例: d3 のように入力してください。')
# プログラムの実行
if __name__ == '__main__':
main()
プロンプトno2(GUIの設定1と初期動作:相互手動)
# 1. ゲームボードの初期化
# 盤面を表すための定数を定義します
# '・' : 空, '⚫' : 黒, '⚪' : 白
EMPTY = '・'
BLACK = '⚫'
WHITE = '⚪'
def create_board():
"""
8x8の空の盤面を作成し、初期配置の石を配置します。
"""
board = []
for _ in range(8):
row = [EMPTY] * 8
board.append(row)
board[3][3] = WHITE
board[3][4] = BLACK
board[4][3] = BLACK
board[4][4] = WHITE
return board
# 2. ボードの表示
def print_board(board):
"""
現在の盤面をきれいに表示します。
"""
# 列の表記を修正
print(' a b c d e f g h')
# 罫線の表示
print(' +---+---+---+---+---+---+---+---+---+---')
for i in range(8):
# 行の表示と升目の調整
row_str = f'{i+1} |'
for j in range(8):
row_str += f' {board[i][j]} |'
print(row_str)
print(' +---+---+---+---+---+---+---+---+---+---')
# 3. 駒を置ける場所の判定と駒の反転
def is_valid_move(board, row, col, player, opponent):
"""
指定された位置に石を置くことができるか判定し、
ひっくり返せる石のリストを返します。
"""
if not (0 <= row < 8 and 0 <= col < 8) or board[row][col] != EMPTY:
return None
# 8つの方向を定義 (行の変化, 列の変化)
directions = [
(-1, -1), (-1, 0), (-1, 1),
(0, -1), (0, 1),
(1, -1), (1, 0), (1, 1)
]
pieces_to_flip = []
for dr, dc in directions:
r, c = row + dr, col + dc
path = []
while 0 <= r < 8 and 0 <= c < 8 and board[r][c] == opponent:
path.append((r, c))
r, c = r + dr, c + dc
# 挟み込んでいるかチェック
if 0 <= r < 8 and 0 <= c < 8 and board[r][c] == player and path:
pieces_to_flip.extend(path)
return pieces_to_flip if pieces_to_flip else None
def flip_pieces(board, pieces_to_flip, player):
"""
ひっくり返す石のリストを、指定されたプレイヤーの石に変換します。
"""
for r, c in pieces_to_flip:
board[r][c] = player
def get_valid_moves(board, player, opponent):
"""
現在のプレイヤーが石を置けるすべての場所（有効な手）のリストを返します。
"""
valid_moves = []
for r in range(8):
for c in range(8):
if board[r][c] == EMPTY:
if is_valid_move(board, r, c, player, opponent):
valid_moves.append((r, c))
return valid_moves
def count_pieces(board):
"""
盤面上の石の数を数え、勝敗を表示します。
"""
black_count = 0
white_count = 0
for r in range(8):
for c in range(8):
if board[r][c] == BLACK:
black_count += 1
elif board[r][c] == WHITE:
white_count += 1
print(f"最終結果：黒 = {black_count}、白 = {white_count}")
if black_count > white_count:
print("黒の勝ちです！")
elif white_count > black_count:
print("白の勝ちです！")
else:
print("引き分けです。")
# 4. メインゲームループ
def main():
"""
ゲームのメイン処理を実行します。
"""
board = create_board()
player_turn = BLACK
opponent_turn = WHITE
pass_count = 0 # 連続でパスした回数をカウント
while True:
print_board(board)
valid_moves = get_valid_moves(board, player_turn, opponent_turn)
if not valid_moves:
pass_count += 1
print(f'現在のターン: {"黒" if player_turn == BLACK else "白"}')
print("置ける場所がありません。パスします。")
if pass_count == 2:
print("両プレイヤーがパスしました。ゲームを終了します。")
break
player_turn, opponent_turn = opponent_turn, player_turn
continue
else:
pass_count = 0
print(f'現在のターン: {"黒" if player_turn == BLACK else "白"}')
try:
move_str = input('駒を置く場所を入力してください (例: d3): ')
if move_str.lower() == 'q':
print("ゲームを終了します。")
break
col_char = move_str[0].lower()
row_char = move_str[1:]
col = 'abcdefgh'.index(col_char)
row = int(row_char) - 1
if (row, col) not in valid_moves:
print('その場所には置けません。有効な手を打ってください。')
continue
pieces_to_flip = is_valid_move(board, row, col, player_turn, opponent_turn)
board[row][col] = player_turn
flip_pieces(board, pieces_to_flip, player_turn)
player_turn, opponent_turn = opponent_turn, player_turn
except (ValueError, IndexError):
print('無効な入力です。例: d3 のように入力してください。')
print("ゲーム終了！")
count_pieces(board)
input("結果を確認後、何かキーを押して終了してください...")
# プログラムの実行
if __name__ == '__main__':
main()
プロンプトno3(GUIの設定2と初期動作:相互手動:盤面ほぼ完成)
import tkinter as tk
from tkinter import messagebox
# 盤面を表すための定数
EMPTY = '・'
BLACK = '⚫'
WHITE = '⚪'
# ウィンドウとキャンバスのサイズ
BOARD_SIZE = 400
CELL_SIZE = BOARD_SIZE // 8
# グローバル変数としてボードの状態を保持
game_board = None
canvas = None
current_player = BLACK
pass_count = 0
def create_board():
"""
8x8の空の盤面を作成し、初期配置の石を配置します。
"""
board = []
for _ in range(8):
row = [EMPTY] * 8
board.append(row)
board[3][3] = WHITE
board[3][4] = BLACK
board[4][3] = BLACK
board[4][4] = WHITE
return board
def is_valid_move(board, row, col, player, opponent):
"""
指定された位置に石を置くことができるか判定し、
ひっくり返せる石のリストを返します。
"""
if not (0 <= row < 8 and 0 <= col < 8) or board[row][col] != EMPTY:
return None
directions = [
(-1, -1), (-1, 0), (-1, 1),
(0, -1), (0, 1),
(1, -1), (1, 0), (1, 1)
]
pieces_to_flip = []
for dr, dc in directions:
r, c = row + dr, col + dc
path = []
while 0 <= r < 8 and 0 <= c < 8 and board[r][c] == opponent:
path.append((r, c))
r, c = r + dr, c + dc
if 0 <= r < 8 and 0 <= c < 8 and board[r][c] == player and path:
pieces_to_flip.extend(path)
return pieces_to_flip if pieces_to_flip else None
def flip_pieces(board, pieces_to_flip, player):
"""
ひっくり返す石のリストを、指定されたプレイヤーの石に変換します。
"""
for r, c in pieces_to_flip:
board[r][c] = player
def get_valid_moves(board, player, opponent):
"""
現在のプレイヤーが石を置けるすべての場所（有効な手）のリストを返します。
"""
valid_moves = []
for r in range(8):
for c in range(8):
if board[r][c] == EMPTY:
if is_valid_move(board, r, c, player, opponent):
valid_moves.append((r, c))
return valid_moves
def count_pieces(board):
"""
盤面上の石の数を数え、勝敗を決定します。
"""
black_count = sum(row.count(BLACK) for row in board)
white_count = sum(row.count(WHITE) for row in board)
return black_count, white_count
def end_game_check():
"""
ゲームが終了したかチェックし、終了していれば勝敗を表示します。
"""
global pass_count
black_count, white_count = count_pieces(game_board)
if pass_count == 2 or (black_count + white_count) == 64:
# ゲーム終了
if black_count > white_count:
message = f"ゲーム終了！\n黒の勝ちです！\n(黒: {black_count}, 白: {white_count})"
elif white_count > black_count:
message = f"ゲーム終了！\n白の勝ちです！\n(黒: {black_count}, 白: {white_count})"
else:
message = f"ゲーム終了！\n引き分けです！\n(黒: {black_count}, 白: {white_count})"
messagebox.showinfo("ゲーム終了", message)
return True
return False
def draw_pieces():
"""
Pythonのボード情報に基づいて、canvas上に石を描画します。
"""
canvas.delete("all")
# 盤面の升目を再描画
for i in range(8):
for j in range(8):
x1 = j * CELL_SIZE
y1 = i * CELL_SIZE
x2 = x1 + CELL_SIZE
y2 = y1 + CELL_SIZE
canvas.create_rectangle(x1, y1, x2, y2, outline="black", fill="green")
# 石を描画
for row_idx in range(8):
for col_idx in range(8):
piece = game_board[row_idx][col_idx]
if piece == BLACK:
color = "black"
elif piece == WHITE:
color = "white"
else:
continue
x1 = col_idx * CELL_SIZE + 5
y1 = row_idx * CELL_SIZE + 5
x2 = x1 + CELL_SIZE - 10
y2 = y1 + CELL_SIZE - 10
canvas.create_oval(x1, y1, x2, y2, fill=color, outline="black")
def on_click(event):
"""
マウスがクリックされたときに呼び出される関数です。
"""
global current_player, pass_count
col = event.x // CELL_SIZE
row = event.y // CELL_SIZE
opponent_player = WHITE if current_player == BLACK else BLACK
pieces_to_flip = is_valid_move(game_board, row, col, current_player, opponent_player)
if pieces_to_flip:
# 有効な手であれば、石を置く
game_board[row][col] = current_player
flip_pieces(game_board, pieces_to_flip, current_player)
# プレイヤーを交代
current_player = opponent_player
pass_count = 0 # パスカウントをリセット
else:
# 無効な手の場合、何もしない
return
draw_pieces()
# 相手プレイヤーに有効な手があるかチェック
if not get_valid_moves(game_board, current_player, opponent_player):
print(f'{current_player}は置ける場所がありません。パスします。')
pass_count += 1
current_player = opponent_player # プレイヤーを再度交代
# 連続パスの場合、ゲーム終了チェック
if pass_count == 2:
end_game_check()
else:
# パスしたので、盤面を再描画して次のプレイヤーの番
draw_pieces()
# ゲーム終了条件を常にチェック
if not end_game_check():
pass
else:
print("ゲームが終了しました。")
def create_gui_board():
"""
tkinterのウィンドウとオセロ盤のGUIを作成します。
"""
global game_board, canvas
root = tk.Tk()
root.title("オセロゲーム")
canvas = tk.Canvas(root, width=BOARD_SIZE, height=BOARD_SIZE, bg="green")
canvas.pack()
canvas.bind("<Button-1>", on_click)
game_board = create_board()
draw_pieces()
root.mainloop()
# プログラムの実行
if __name__ == "__main__":
create_gui_board()
プロンプトno4(AI対戦相手のプログラムと初期動作)
import tkinter as tk
from tkinter import messagebox
import random # <--- ここを追加
# 盤面を表すための定数
EMPTY = '・'
BLACK = '⚫'
WHITE = '⚪'
# ウィンドウとキャンバスのサイズ
BOARD_SIZE = 400
CELL_SIZE = BOARD_SIZE // 8
# グローバル変数としてボードの状態を保持
game_board = None
canvas = None
current_player = BLACK
pass_count = 0
# AIの設定
AI_PLAYER = WHITE # AIを白のプレイヤーに設定
IS_AI_TURN = False # AIのターンかどうかを示すフラグ
def create_board():
"""
8x8の空の盤面を作成し、初期配置の石を配置します。
"""
board = []
for _ in range(8):
row = [EMPTY] * 8
board.append(row)
board[3][3] = WHITE
board[3][4] = BLACK
board[4][3] = BLACK
board[4][4] = WHITE
return board
# ----------------- AIロジックの追加 -----------------
def get_ai_move(valid_moves):
"""
有効な手の中からランダムに手を選択します。
"""
return random.choice(valid_moves)
def handle_ai_turn():
"""
AIのターンを処理します。
"""
global current_player, pass_count, IS_AI_TURN
opponent_player = BLACK # AIは白なので、相手は黒
valid_moves = get_valid_moves(game_board, AI_PLAYER, opponent_player)
if not valid_moves:
pass_count += 1
print("AIは置ける場所がありません。パスします。")
current_player = BLACK # プレイヤーを交代
IS_AI_TURN = False
end_game_check()
draw_pieces()
else:
pass_count = 0
# AIがランダムに手を選択
row, col = get_ai_move(valid_moves)
# 石を置く処理
pieces_to_flip = is_valid_move(game_board, row, col, AI_PLAYER, opponent_player)
game_board[row][col] = AI_PLAYER
flip_pieces(game_board, pieces_to_flip, AI_PLAYER)
current_player = BLACK # プレイヤーを交代
IS_AI_TURN = False
draw_pieces()
if not end_game_check():
pass
else:
print("ゲームが終了しました。")
def on_click(event):
"""
マウスがクリックされたときに呼び出される関数です。
"""
global current_player, pass_count, IS_AI_TURN
if IS_AI_TURN:
return # AIのターン中はプレイヤーの入力を無視
col = event.x // CELL_SIZE
row = event.y // CELL_SIZE
opponent_player = WHITE # プレイヤーは黒なので、相手は白
pieces_to_flip = is_valid_move(game_board, row, col, current_player, opponent_player)
if pieces_to_flip:
game_board[row][col] = current_player
flip_pieces(game_board, pieces_to_flip, current_player)
pass_count = 0
current_player = opponent_player
IS_AI_TURN = True # 次のターンはAI
draw_pieces()
if not end_game_check():
canvas.after(500, handle_ai_turn) # 0.5秒後にAIを動かす
else:
print("ゲームが終了しました。")
else:
print("その場所には置けません。有効な手を打ってください。")
# ----------------- ここから下の関数は変更なし -----------------
def is_valid_move(board, row, col, player, opponent):
if not (0 <= row < 8 and 0 <= col < 8) or board[row][col] != EMPTY:
return None
directions = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
pieces_to_flip = []
for dr, dc in directions:
r, c = row + dr, col + dc
path = []
while 0 <= r < 8 and 0 <= c < 8 and board[r][c] == opponent:
path.append((r, c))
r, c = r + dr, c + dc
if 0 <= r < 8 and 0 <= c < 8 and board[r][c] == player and path:
pieces_to_flip.extend(path)
return pieces_to_flip if pieces_to_flip else None
def flip_pieces(board, pieces_to_flip, player):
for r, c in pieces_to_flip:
board[r][c] = player
def get_valid_moves(board, player, opponent):
valid_moves = []
for r in range(8):
for c in range(8):
if board[r][c] == EMPTY:
if is_valid_move(board, r, c, player, opponent):
valid_moves.append((r, c))
return valid_moves
def count_pieces(board):
black_count = sum(row.count(BLACK) for row in board)
white_count = sum(row.count(WHITE) for row in board)
return black_count, white_count
def end_game_check():
global pass_count
black_count, white_count = count_pieces(game_board)
if pass_count == 2 or (black_count + white_count) == 64:
if black_count > white_count:
message = f"ゲーム終了！\n黒の勝ちです！\n(黒: {black_count}, 白: {white_count})"
elif white_count > black_count:
message = f"ゲーム終了！\n白の勝ちです！\n(黒: {black_count}, 白: {white_count})"
else:
message = f"ゲーム終了！\n引き分けです！\n(黒: {black_count}, 白: {white_count})"
messagebox.showinfo("ゲーム終了", message)
return True
return False
def draw_pieces():
canvas.delete("all")
for i in range(8):
for j in range(8):
x1 = j * CELL_SIZE
y1 = i * CELL_SIZE
x2 = x1 + CELL_SIZE
y2 = y1 + CELL_SIZE
canvas.create_rectangle(x1, y1, x2, y2, outline="black", fill="green")
for row_idx in range(8):
for col_idx in range(8):
piece = game_board[row_idx][col_idx]
if piece == BLACK:
color = "black"
elif piece == WHITE:
color = "white"
else:
continue
x1 = col_idx * CELL_SIZE + 5
y1 = row_idx * CELL_SIZE + 5
x2 = x1 + CELL_SIZE - 10
y2 = y1 + CELL_SIZE - 10
canvas.create_oval(x1, y1, x2, y2, fill=color, outline="black")
def create_gui_board():
global game_board, canvas
root = tk.Tk()
root.title("オセロゲーム")
canvas = tk.Canvas(root, width=BOARD_SIZE, height=BOARD_SIZE, bg="green")
canvas.pack()
canvas.bind("<Button-1>", on_click)
game_board = create_board()
draw_pieces()
root.mainloop()
if __name__ == "__main__":
create_gui_board()
プロンプトno5(AI対戦相手のGUI改善:ヒント表示と初期動作)
import tkinter as tk
from tkinter import messagebox
import copy
import time
import sys
# --- ゲーム定数 ---
BOARD_SIZE = 8
CELL_SIZE = 60
WINDOW_SIZE = BOARD_SIZE * CELL_SIZE
SIDE_PANEL_WIDTH = 150
AI_PLAYER = 2 # 2: 黒 (後攻) / 1: 白 (先攻)
SEARCH_DEPTH = 4 # AIの探索深さ
# --- グローバル変数 ---
root = None
canvas = None
board = None
current_player = 1 # 1:白, 2:黒
game_running = True
score_label = None
turn_label = None
history = []
# --- 初期化 ---
def create_initial_board():
"""初期盤面を作成 (0:空, 1:白, 2:黒)"""
new_board = [[0] * BOARD_SIZE for _ in range(BOARD_SIZE)]
new_board[3][3] = 1 # 白
new_board[3][4] = 2 # 黒
new_board[4][3] = 2 # 黒
new_board[4][4] = 1 # 白
return new_board
# --- ルールとAIロジック ---
def is_valid_move(r, c, player, current_board):
"""指定されたマスに駒を置けるかチェックし、裏返せる駒のリストを返す"""
if current_board[r][c] != 0:
return []
opponent = 3 - player
flips = []
# 8方向をチェック
directions = [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (-1, 1), (1, -1), (1, 1)]
for dr, dc in directions:
line_flips = []
rr, cc = r + dr, c + dc
# 相手の駒が続く限り進む
while 0 <= rr < BOARD_SIZE and 0 <= cc < BOARD_SIZE and current_board[rr][cc] == opponent:
line_flips.append((rr, cc))
rr, cc = rr + dr, cc + dc
# 終点が自分の駒で、間に裏返せる駒がある場合
if line_flips and 0 <= rr < BOARD_SIZE and 0 <= cc < BOARD_SIZE and current_board[rr][cc] == player:
flips.extend(line_flips)
return flips
def get_valid_moves(player, current_board):
"""合法手の一覧を (r, c) のリストで返す"""
valid_moves = []
for r in range(BOARD_SIZE):
for c in range(BOARD_SIZE):
if is_valid_move(r, c, player, current_board):
valid_moves.append((r, c))
return valid_moves
def apply_move(r, c, player, current_board):
"""実際に駒を置き、盤面を更新する (新しい盤面を返す)"""
new_board = [row[:] for row in current_board]
flips = is_valid_move(r, c, player, current_board)
if not flips:
return new_board # 無効な手の場合は元の盤面を返す
new_board[r][c] = player
for fr, fc in flips:
new_board[fr][fc] = player
return new_board
def evaluate_board(current_board, player):
"""評価関数: 駒の数の差を計算"""
p1_count = sum(row.count(1) for row in current_board)
p2_count = sum(row.count(2) for row in current_board)
if player == 1:
return p1_count - p2_count
else:
return p2_count - p1_count
def minimax(current_board, depth, is_maximizing_player, alpha, beta):
"""Minimax with Alpha-Beta Pruning"""
current_player_minimax = 2 if is_maximizing_player else 1
# 終端条件
valid_moves = get_valid_moves(current_player_minimax, current_board)
if depth == 0 or (not valid_moves and not get_valid_moves(3 - current_player_minimax, current_board)):
return evaluate_board(current_board, 2), None # AI(黒=2)視点の評価を返す
best_move = None
if is_maximizing_player: # AI (黒=2) の手番
max_eval = -float('inf')
for r, c in valid_moves:
new_board = apply_move(r, c, 2, current_board)
current_eval, _ = minimax(new_board, depth - 1, False, alpha, beta)
if current_eval > max_eval:
max_eval = current_eval
best_move = (r, c)
alpha = max(alpha, max_eval)
if beta <= alpha:
break
return max_eval, best_move
else: # プレイヤー (白=1) の手番
min_eval = float('inf')
for r, c in valid_moves:
new_board = apply_move(r, c, 1, current_board)
current_eval, _ = minimax(new_board, depth - 1, True, alpha, beta)
if current_eval < min_eval:
min_eval = current_eval
best_move = (r, c)
beta = min(beta, min_eval)
if beta <= alpha:
break
return min_eval, best_move
def find_best_move(current_board, depth):
start_time = time.time()
_, best_move = minimax(current_board, depth, True, -float('inf'), float('inf'))
end_time = time.time()
print(f"Minimax探索時間: {end_time - start_time:.2f}秒 (深さ: {depth})")
return best_move
# --- UIと描画 ---
def draw_board():
"""盤面を描画し、駒を配置する"""
canvas.delete("all")
# 盤面のグリッド線を描画
for i in range(BOARD_SIZE + 1):
# 垂直線
canvas.create_line(i * CELL_SIZE, 0, i * CELL_SIZE, WINDOW_SIZE, fill="black")
# 水平線
canvas.create_line(0, i * CELL_SIZE, WINDOW_SIZE, i * CELL_SIZE, fill="black")
# 駒の配置
for r in range(BOARD_SIZE):
for c in range(BOARD_SIZE):
player = board[r][c]
if player != 0:
x1 = c * CELL_SIZE + 5
y1 = r * CELL_SIZE + 5
x2 = (c + 1) * CELL_SIZE - 5
y2 = (r + 1) * CELL_SIZE - 5
color = "white" if player == 1 else "black"
canvas.create_oval(x1, y1, x2, y2, fill=color, outline="black")
update_score_display()
def update_score_display():
"""スコアとターン表示を更新する"""
p1_count = sum(row.count(1) for row in board)
p2_count = sum(row.count(2) for row in board)
score_text = f"白: {p1_count}\n黒: {p2_count}"
turn_text = f"現在のターン: {'白' if current_player == 1 else '黒'}"
if score_label and turn_label:
score_label.config(text=score_text)
turn_label.config(text=turn_text)
def show_hint():
"""合法手があるマスをハイライト表示する"""
canvas.delete("hint")
valid_moves = get_valid_moves(current_player, board)
for r, c in valid_moves:
x1 = c * CELL_SIZE + 2
y1 = r * CELL_SIZE + 2
x2 = (c + 1) * CELL_SIZE - 2
y2 = (r + 1) * CELL_SIZE - 2
canvas.create_rectangle(x1, y1, x2, y2, outline="yellow", width=3, tags="hint")
# --- イベントハンドラ ---
def handle_click(event):
"""マウスがクリックされたときの処理"""
global board, current_player, game_running
if not game_running or current_player == AI_PLAYER:
return
c = event.x // CELL_SIZE
r = event.y // CELL_SIZE
if not (0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE):
return
flips = is_valid_move(r, c, current_player, board)
if flips:
save_state() # 履歴保存
board = apply_move(r, c, current_player, board)
next_player = 3 - current_player
end_turn(next_player)
else:
messagebox.showinfo("無効な手", "そこには置けません。")
def end_turn(next_player):
"""ターン終了時の処理"""
global current_player, game_running
current_player = next_player
draw_board()
p1_moves = get_valid_moves(1, board)
p2_moves = get_valid_moves(2, board)
if not p1_moves and not p2_moves:
# 両者とも置けない = ゲーム終了
game_running = False
p1_count = sum(row.count(1) for row in board)
p2_count = sum(row.count(2) for row in board)
winner = "引き分け"
if p1_count > p2_count: winner = "白の勝利"
elif p2_count > p1_count: winner = "黒の勝利"
messagebox.showinfo("ゲーム終了", f"最終スコア 白:{p1_count}, 黒:{p2_count}\n{winner}")
return
elif not get_valid_moves(current_player, board):
# パス (合法手が無い場合は相手のターンに戻る)
messagebox.showinfo("パス", f"{'白' if current_player == 1 else '黒'}は置く場所がないためパスします。")
current_player = 3 - current_player
draw_board() # プレイヤーが変わったことを表示
show_hint()
if current_player == AI_PLAYER and game_running:
root.after(500, make_ai_move) # 0.5秒後にAIを起動
def make_ai_move():
"""AIが指し手を決定し、実行する"""
global board, current_player, game_running
if not game_running or current_player != AI_PLAYER:
return
save_state() # 履歴保存
best_move = find_best_move(board, SEARCH_DEPTH)
if best_move:
r, c = best_move
board = apply_move(r, c, AI_PLAYER, board)
next_player = 3 - AI_PLAYER
end_turn(next_player)
else:
# AIが置けない場合もパス処理で end_turn が実行される
end_turn(3 - AI_PLAYER)
def save_state():
"""現在のゲーム状態を履歴に保存する (Undo用)"""
global history
state = (
[row[:] for row in board],
current_player
)
history.append(state)
def undo_move():
"""一手前の状態に戻す"""
global board, current_player, game_running, history
if current_player == AI_PLAYER:
messagebox.showinfo("警告", "AIの手番中はUndoできません。")
return
if len(history) <= 1:
messagebox.showinfo("警告", "初期状態のため、これ以上戻せません。")
return
# プレイヤーとAIの2手分を戻す
if len(history) >= 2:
history.pop() # AIの手
history.pop() # プレイヤーの手
else:
# 初期盤面直後の履歴の場合
history.pop()
prev_board, prev_player = history[-1]
board = [row[:] for row in prev_board]
current_player = prev_player
game_running = True
draw_board()
show_hint()
if current_player == AI_PLAYER and game_running:
root.after(500, make_ai_move)
# --- GUIメイン関数 ---
def create_board_ui():
global root, canvas, board, score_label, turn_label
root = tk.Tk()
root.title(f"オセロゲーム (AI深さ: {SEARCH_DEPTH})")
# --- UI中央配置のための改善 ---
# 1. すべての要素を保持するメインフレームを作成
main_frame = tk.Frame(root)
# 2. main_frameを親ウィンドウの中央に配置
# expand=True で利用可能なスペースを広げ、anchor='center' で中央に寄せます。
main_frame.pack(expand=True, anchor='center')
# --------------------------------
# 3. ボード（キャンバス）を main_frame の中に配置 (親を root から main_frame に変更)
canvas = tk.Canvas(main_frame, width=WINDOW_SIZE, height=WINDOW_SIZE, bg="green")
canvas.pack(side=tk.LEFT)
# 4. スコアパネル（サイドパネル）を main_frame の中に配置 (親を root から main_frame に変更)
score_frame = tk.Frame(main_frame, width=SIDE_PANEL_WIDTH)
score_frame.pack(side=tk.RIGHT, fill=tk.Y, padx=10, pady=10)
# --- スコアとターン表示 ---
score_label = tk.Label(score_frame, text="スコア", font=("Arial", 16))
score_label.pack(pady=20)
turn_label = tk.Label(score_frame, text="ターン", font=("Arial", 14))
turn_label.pack(pady=10)
# --- ボタン ---
undo_button = tk.Button(score_frame, text="一手戻る (Undo)", command=undo_move,
height=2, bg="#B0C4DE", fg="black")
undo_button.pack(pady=20)
hint_button = tk.Button(score_frame, text="ヒント表示", command=show_hint,
height=2, bg="#FFFACD", fg="black")
hint_button.pack(pady=10)
# --- ゲームの起動 ---
board = create_initial_board()
canvas.bind("<Button-1>", handle_click)
# 初期状態を履歴に保存
save_state()
draw_board()
show_hint()
def on_closing():
root.destroy()
sys.exit()
root.protocol("WM_DELETE_WINDOW", on_closing)
root.mainloop()
if __name__ == "__main__":
create_board_ui()
プロンプトno6(AI対戦相手の完全版ヒント表示の選択機能の追加と初期動作)
import tkinter as tk
from tkinter import messagebox
import copy
import time
import sys
# --- ゲーム定数 ---
BOARD_SIZE = 8
CELL_SIZE = 60
WINDOW_SIZE = BOARD_SIZE * CELL_SIZE
SIDE_PANEL_WIDTH = 150
AI_PLAYER = 2 # 2: 黒 (後攻) / 1: 白 (先攻)
SEARCH_DEPTH = 4 # AIの探索深さ
# --- グローバル変数 ---
root = None
canvas = None
board = None
current_player = 1 # 1:白, 2:黒
game_running = True
score_label = None
turn_label = None
history = []
# --- 初期化 ---
def create_initial_board():
"""初期盤面を作成 (0:空, 1:白, 2:黒)"""
new_board = [[0] * BOARD_SIZE for _ in range(BOARD_SIZE)]
new_board[3][3] = 1 # 白
new_board[3][4] = 2 # 黒
new_board[4][3] = 2 # 黒
new_board[4][4] = 1 # 白
return new_board
# --- ルールとAIロジック ---
def is_valid_move(r, c, player, current_board):
"""指定されたマスに駒を置けるかチェックし、裏返せる駒のリストを返す"""
if current_board[r][c] != 0:
return []
opponent = 3 - player
flips = []
# 8方向をチェック
directions = [(-1, 0), (1, 0), (0, -1), (0, 1), (-1, -1), (-1, 1), (1, -1), (1, 1)]
for dr, dc in directions:
line_flips = []
rr, cc = r + dr, c + dc
# 相手の駒が続く限り進む
while 0 <= rr < BOARD_SIZE and 0 <= cc < BOARD_SIZE and current_board[rr][cc] == opponent:
line_flips.append((rr, cc))
rr, cc = rr + dr, cc + dc
# 終点が自分の駒で、間に裏返せる駒がある場合
if line_flips and 0 <= rr < BOARD_SIZE and 0 <= cc < BOARD_SIZE and current_board[rr][cc] == player:
flips.extend(line_flips)
return flips
def get_valid_moves(player, current_board):
"""合法手の一覧を (r, c) のリストで返す"""
valid_moves = []
for r in range(BOARD_SIZE):
for c in range(BOARD_SIZE):
if is_valid_move(r, c, player, current_board):
valid_moves.append((r, c))
return valid_moves
def apply_move(r, c, player, current_board):
"""実際に駒を置き、盤面を更新する (新しい盤面を返す)"""
new_board = [row[:] for row in current_board]
flips = is_valid_move(r, c, player, current_board)
if not flips:
return new_board # 無効な手の場合は元の盤面を返す
new_board[r][c] = player
for fr, fc in flips:
new_board[fr][fc] = player
return new_board
def evaluate_board(current_board, player):
"""評価関数: 駒の数の差を計算"""
p1_count = sum(row.count(1) for row in current_board)
p2_count = sum(row.count(2) for row in current_board)
if player == 1:
return p1_count - p2_count
else:
return p2_count - p1_count
def minimax(current_board, depth, is_maximizing_player, alpha, beta):
"""Minimax with Alpha-Beta Pruning"""
current_player_minimax = 2 if is_maximizing_player else 1
# 終端条件
valid_moves = get_valid_moves(current_player_minimax, current_board)
if depth == 0 or (not valid_moves and not get_valid_moves(3 - current_player_minimax, current_board)):
return evaluate_board(current_board, 2), None # AI(黒=2)視点の評価を返す
best_move = None
if is_maximizing_player: # AI (黒=2) の手番
max_eval = -float('inf')
for r, c in valid_moves:
new_board = apply_move(r, c, 2, current_board)
current_eval, _ = minimax(new_board, depth - 1, False, alpha, beta)
if current_eval > max_eval:
max_eval = current_eval
best_move = (r, c)
alpha = max(alpha, max_eval)
if beta <= alpha:
break
return max_eval, best_move
else: # プレイヤー (白=1) の手番
min_eval = float('inf')
for r, c in valid_moves:
new_board = apply_move(r, c, 1, current_board)
current_eval, _ = minimax(new_board, depth - 1, True, alpha, beta)
if current_eval < min_eval:
min_eval = current_eval
best_move = (r, c)
beta = min(beta, min_eval)
if beta <= alpha:
break
return min_eval, best_move
def find_best_move(current_board, depth):
start_time = time.time()
_, best_move = minimax(current_board, depth, True, -float('inf'), float('inf'))
end_time = time.time()
print(f"Minimax探索時間: {end_time - start_time:.2f}秒 (深さ: {depth})")
return best_move
# --- UIと描画 ---
def draw_board():
"""盤面を描画し、駒を配置する"""
canvas.delete("all")
# 盤面のグリッド線を描画
for i in range(BOARD_SIZE + 1):
# 垂直線
canvas.create_line(i * CELL_SIZE, 0, i * CELL_SIZE, WINDOW_SIZE, fill="black")
# 水平線
canvas.create_line(0, i * CELL_SIZE, WINDOW_SIZE, i * CELL_SIZE, fill="black")
# 駒の配置
for r in range(BOARD_SIZE):
for c in range(BOARD_SIZE):
player = board[r][c]
if player != 0:
x1 = c * CELL_SIZE + 5
y1 = r * CELL_SIZE + 5
x2 = (c + 1) * CELL_SIZE - 5
y2 = (r + 1) * CELL_SIZE - 5
color = "white" if player == 1 else "black"
canvas.create_oval(x1, y1, x2, y2, fill=color, outline="black")
update_score_display()
def update_score_display():
"""スコアとターン表示を更新する"""
p1_count = sum(row.count(1) for row in board)
p2_count = sum(row.count(2) for row in board)
score_text = f"白: {p1_count}\n黒: {p2_count}"
turn_text = f"現在のターン: {'白' if current_player == 1 else '黒'}"
if score_label and turn_label:
score_label.config(text=score_text)
turn_label.config(text=turn_text)
def show_hint():
"""合法手があるマスをハイライト表示する"""
canvas.delete("hint")
valid_moves = get_valid_moves(current_player, board)
for r, c in valid_moves:
x1 = c * CELL_SIZE + 2
y1 = r * CELL_SIZE + 2
x2 = (c + 1) * CELL_SIZE - 2
y2 = (r + 1) * CELL_SIZE - 2
canvas.create_rectangle(x1, y1, x2, y2, outline="yellow", width=3, tags="hint")
# --- イベントハンドラ ---
def handle_click(event):
"""マウスがクリックされたときの処理"""
global board, current_player, game_running
if not game_running or current_player == AI_PLAYER:
return
c = event.x // CELL_SIZE
r = event.y // CELL_SIZE
if not (0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE):
return
flips = is_valid_move(r, c, current_player, board)
if flips:
save_state() # 履歴保存
board = apply_move(r, c, current_player, board)
next_player = 3 - current_player
end_turn(next_player)
else:
messagebox.showinfo("無効な手", "そこには置けません。")
def end_turn(next_player):
"""ターン終了時の処理"""
global current_player, game_running
current_player = next_player
draw_board()
p1_moves = get_valid_moves(1, board)
p2_moves = get_valid_moves(2, board)
if not p1_moves and not p2_moves:
# 両者とも置けない = ゲーム終了
game_running = False
p1_count = sum(row.count(1) for row in board)
p2_count = sum(row.count(2) for row in board)
winner = "引き分け"
if p1_count > p2_count: winner = "白の勝利"
elif p2_count > p1_count: winner = "黒の勝利"
messagebox.showinfo("ゲーム終了", f"最終スコア 白:{p1_count}, 黒:{p2_count}\n{winner}")
return
elif not get_valid_moves(current_player, board):
# パス (合法手が無い場合は相手のターンに戻る)
messagebox.showinfo("パス", f"{'白' if current_player == 1 else '黒'}は置く場所がないためパスします。")
current_player = 3 - current_player
draw_board() # プレイヤーが変わったことを表示
show_hint()
if current_player == AI_PLAYER and game_running:
root.after(500, make_ai_move) # 0.5秒後にAIを起動
def make_ai_move():
"""AIが指し手を決定し、実行する"""
global board, current_player, game_running
if not game_running or current_player != AI_PLAYER:
return
save_state() # 履歴保存
best_move = find_best_move(board, SEARCH_DEPTH)
if best_move:
r, c = best_move
board = apply_move(r, c, AI_PLAYER, board)
next_player = 3 - AI_PLAYER
end_turn(next_player)
else:
# AIが置けない場合もパス処理で end_turn が実行される
end_turn(3 - AI_PLAYER)
def save_state():
"""現在のゲーム状態を履歴に保存する (Undo用)"""
global history
state = (
[row[:] for row in board],
current_player
)
history.append(state)
def undo_move():
"""一手前の状態に戻す"""
global board, current_player, game_running, history
if current_player == AI_PLAYER:
messagebox.showinfo("警告", "AIの手番中はUndoできません。")
return
if len(history) <= 1:
messagebox.showinfo("警告", "初期状態のため、これ以上戻せません。")
return
# プレイヤーとAIの2手分を戻す
if len(history) >= 2:
history.pop() # AIの手
history.pop() # プレイヤーの手
else:
# 初期盤面直後の履歴の場合
history.pop()
prev_board, prev_player = history[-1]
board = [row[:] for row in prev_board]
current_player = prev_player
game_running = True
draw_board()
show_hint()
if current_player == AI_PLAYER and game_running:
root.after(500, make_ai_move)
# --- GUIメイン関数 ---
def create_board_ui():
global root, canvas, board, score_label, turn_label
root = tk.Tk()
root.title(f"オセロゲーム (AI深さ: {SEARCH_DEPTH})")
# --- UI中央配置のための改善 ---
# 1. すべての要素を保持するメインフレームを作成
main_frame = tk.Frame(root)
# 2. main_frameを親ウィンドウの中央に配置
# expand=True で利用可能なスペースを広げ、anchor='center' で中央に寄せます。
main_frame.pack(expand=True, anchor='center')
# --------------------------------
# 3. ボード（キャンバス）を main_frame の中に配置 (親を root から main_frame に変更)
canvas = tk.Canvas(main_frame, width=WINDOW_SIZE, height=WINDOW_SIZE, bg="green")
canvas.pack(side=tk.LEFT)
# 4. スコアパネル（サイドパネル）を main_frame の中に配置 (親を root から main_frame に変更)
score_frame = tk.Frame(main_frame, width=SIDE_PANEL_WIDTH)
score_frame.pack(side=tk.RIGHT, fill=tk.Y, padx=10, pady=10)
# --- スコアとターン表示 ---
score_label = tk.Label(score_frame, text="スコア", font=("Arial", 16))
score_label.pack(pady=20)
turn_label = tk.Label(score_frame, text="ターン", font=("Arial", 14))
turn_label.pack(pady=10)
# --- ボタン ---
undo_button = tk.Button(score_frame, text="一手戻る (Undo)", command=undo_move,
height=2, bg="#B0C4DE", fg="black")
undo_button.pack(pady=20)
hint_button = tk.Button(score_frame, text="ヒント表示", command=show_hint,
height=2, bg="#FFFACD", fg="black")
hint_button.pack(pady=10)
# --- ゲームの起動 ---
board = create_initial_board()
canvas.bind("<Button-1>", handle_click)
# 初期状態を履歴に保存
save_state()
draw_board()
show_hint()
def on_closing():
root.destroy()
sys.exit()
root.protocol("WM_DELETE_WINDOW", on_closing)
root.mainloop()
if __name__ == "__main__":
create_board_ui()
