cli-othello 0.1.0__tar.gz

cli_othello-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: cli-othello
+Version: 0.1.0
+Summary: Play Othello (Reversi) in your terminal against a 5-level AI
+Author-email: Lapius7 <20071209ryo@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Lapius7/cli-othello
+Project-URL: Repository, https://github.com/Lapius7/cli-othello
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: windows-curses; platform_system == "Windows"
+
+# cli-othello
+
+ターミナルでオセロ（リバーシ）を楽しめるCLIパッケージです。
+5段階の強さから選べるAIと対局できます。
+
+## インストール
+
+```bash
+pip install cli-othello
+```
+
+## 使い方
+
+```bash
+othello
+```
+
+起動すると対局前にAIの強さ（Lv.1〜Lv.5）を選ぶ画面が表示されます。
+強さを指定して直接対局を始めることもできます。
+
+```bash
+othello --level 3
+```
+
+### 操作方法
+
+| キー | 動作 |
+| --- | --- |
+| ↑ / ↓ / ← / → （または h/j/k/l） | カーソル移動 |
+| Enter / Space | カーソル位置に着手 |
+| q | 終了 |
+
+盤面では、自分が置ける場所が緑色の `·` でハイライトされます。
+
+## AIの強さ
+
+| レベル | 特徴 |
+| --- | --- |
+| Lv.1 入門 | ランダム性が高く、ほぼ気の向くままに着手 |
+| Lv.2 初級 | 浅い探索＋盤面の位置評価を考慮 |
+| Lv.3 中級 | 角・辺の重要度や着手可能数（機動力）も評価 |
+| Lv.4 上級 | より深く先読みしつつ盤面を評価 |
+| Lv.5 最強 | 深い探索（最大6手先）で最も精度高く着手を選択 |
+
+内部的にはミニマックス法とアルファベータ枝刈りを用い、レベルごとに探索の深さと評価関数の精度を変化させています。
+
+## 必要環境
+
+- Python 3.9以上
+- Windowsの場合は `windows-curses` が自動的に依存関係としてインストールされます
+
+## ライセンス
+
+MIT

cli_othello-0.1.0/README.md

@@ -0,0 +1,54 @@
+# cli-othello
+
+ターミナルでオセロ（リバーシ）を楽しめるCLIパッケージです。
+5段階の強さから選べるAIと対局できます。
+
+## インストール
+
+```bash
+pip install cli-othello
+```
+
+## 使い方
+
+```bash
+othello
+```
+
+起動すると対局前にAIの強さ（Lv.1〜Lv.5）を選ぶ画面が表示されます。
+強さを指定して直接対局を始めることもできます。
+
+```bash
+othello --level 3
+```
+
+### 操作方法
+
+| キー | 動作 |
+| --- | --- |
+| ↑ / ↓ / ← / → （または h/j/k/l） | カーソル移動 |
+| Enter / Space | カーソル位置に着手 |
+| q | 終了 |
+
+盤面では、自分が置ける場所が緑色の `·` でハイライトされます。
+
+## AIの強さ
+
+| レベル | 特徴 |
+| --- | --- |
+| Lv.1 入門 | ランダム性が高く、ほぼ気の向くままに着手 |
+| Lv.2 初級 | 浅い探索＋盤面の位置評価を考慮 |
+| Lv.3 中級 | 角・辺の重要度や着手可能数（機動力）も評価 |
+| Lv.4 上級 | より深く先読みしつつ盤面を評価 |
+| Lv.5 最強 | 深い探索（最大6手先）で最も精度高く着手を選択 |
+
+内部的にはミニマックス法とアルファベータ枝刈りを用い、レベルごとに探索の深さと評価関数の精度を変化させています。
+
+## 必要環境
+
+- Python 3.9以上
+- Windowsの場合は `windows-curses` が自動的に依存関係としてインストールされます
+
+## ライセンス
+
+MIT

cli_othello-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cli-othello"
+version = "0.1.0"
+description = "Play Othello (Reversi) in your terminal against a 5-level AI"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Lapius7", email = "20071209ryo@gmail.com" }]
+requires-python = ">=3.9"
+dependencies = [
+    "windows-curses; platform_system=='Windows'",
+]
+
+[project.scripts]
+othello = "cli_othello.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/Lapius7/cli-othello"
+Repository = "https://github.com/Lapius7/cli-othello"
+
+[tool.setuptools.packages.find]
+where = ["src"]

cli_othello-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cli_othello-0.1.0/src/cli_othello/__init__.py

@@ -0,0 +1,3 @@
+"""cli-othello: play Othello in your terminal."""
+
+__version__ = "0.1.0"

cli_othello-0.1.0/src/cli_othello/ai.py

@@ -0,0 +1,157 @@
+"""5-level Othello AI using minimax with alpha-beta pruning.
+
+Each level scales both the search depth and the sophistication of the
+position evaluation, so higher levels look further ahead and judge
+positions more accurately (corners, edges, mobility, stability).
+"""
+
+from __future__ import annotations
+
+import random
+
+from .board import BLACK, EMPTY, SIZE, WHITE, Board, opponent
+
+# Static positional weights, used by the higher levels.
+_POSITION_WEIGHTS = [
+    120, -20, 20, 5, 5, 20, -20, 120,
+    -20, -40, -5, -5, -5, -5, -40, -20,
+    20, -5, 15, 3, 3, 15, -5, 20,
+    5, -5, 3, 3, 3, 3, -5, 5,
+    5, -5, 3, 3, 3, 3, -5, 5,
+    20, -5, 15, 3, 3, 15, -5, 20,
+    -20, -40, -5, -5, -5, -5, -40, -20,
+    120, -20, 20, 5, 5, 20, -20, 120,
+]
+
+_CORNERS = [(0, 0), (0, SIZE - 1), (SIZE - 1, 0), (SIZE - 1, SIZE - 1)]
+
+# level -> (search depth, randomness, use_positional_weights, use_mobility)
+_LEVEL_CONFIG = {
+    1: dict(depth=1, randomness=0.35, weights=False, mobility=False),
+    2: dict(depth=2, randomness=0.15, weights=True, mobility=False),
+    3: dict(depth=2, randomness=0.0, weights=True, mobility=True),
+    4: dict(depth=3, randomness=0.0, weights=True, mobility=True),
+    5: dict(depth=4, randomness=0.0, weights=True, mobility=True),
+}
+
+# Endgame solver: once few enough empty cells remain, search exhaustively
+# to the end of the game instead of stopping at the configured depth.
+_ENDGAME_EMPTY_THRESHOLD = {3: 8, 4: 9, 5: 10}
+
+def _order_moves(moves: list[tuple[int, int]]) -> list[tuple[int, int]]:
+    """Sort moves by static positional weight (best-first) to help alpha-beta
+    pruning cut off more branches earlier."""
+    return sorted(
+        moves, key=lambda m: _POSITION_WEIGHTS[m[0] * SIZE + m[1]], reverse=True
+    )
+
+
+MIN_LEVEL = 1
+MAX_LEVEL = 5
+
+
+class OthelloAI:
+    """Picks moves for `player` at the given difficulty level (1-5)."""
+
+    def __init__(self, player: int, level: int) -> None:
+        if level not in _LEVEL_CONFIG:
+            raise ValueError(f"level must be between {MIN_LEVEL} and {MAX_LEVEL}")
+        self.player = player
+        self.level = level
+        self.config = _LEVEL_CONFIG[level]
+
+    def choose_move(self, board: Board) -> tuple[int, int] | None:
+        moves = board.legal_moves(self.player)
+        if not moves:
+            return None
+
+        if random.random() < self.config["randomness"]:
+            return random.choice(moves)
+
+        depth = self.config["depth"]
+        empty_cells = board.cells.count(EMPTY)
+        endgame_threshold = _ENDGAME_EMPTY_THRESHOLD.get(self.level)
+        if endgame_threshold is not None and empty_cells <= endgame_threshold:
+            depth = empty_cells
+
+        moves = _order_moves(moves)
+        best_score = None
+        best_moves: list[tuple[int, int]] = []
+        for move in moves:
+            child = board.clone()
+            child.play(*move, self.player)
+            score = self._minimax(
+                child, depth - 1, opponent(self.player), -float("inf"), float("inf")
+            )
+            if best_score is None or score > best_score:
+                best_score = score
+                best_moves = [move]
+            elif score == best_score:
+                best_moves.append(move)
+        return random.choice(best_moves)
+
+    def _minimax(
+        self, board: Board, depth: int, turn: int, alpha: float, beta: float
+    ) -> float:
+        if depth <= 0 or board.is_game_over():
+            return self._evaluate(board)
+
+        moves = board.legal_moves(turn)
+        if not moves:
+            return self._minimax(board, depth - 1, opponent(turn), alpha, beta)
+
+        moves = _order_moves(moves)
+        maximizing = turn == self.player
+        best = -float("inf") if maximizing else float("inf")
+        for move in moves:
+            child = board.clone()
+            child.play(*move, turn)
+            score = self._minimax(child, depth - 1, opponent(turn), alpha, beta)
+            if maximizing:
+                best = max(best, score)
+                alpha = max(alpha, best)
+            else:
+                best = min(best, score)
+                beta = min(beta, best)
+            if alpha >= beta:
+                break
+        return best
+
+    def _evaluate(self, board: Board) -> float:
+        me, foe = self.player, opponent(self.player)
+
+        if board.is_game_over():
+            diff = board.count(me) - board.count(foe)
+            return diff * 10000
+
+        if not self.config["weights"]:
+            return board.count(me) - board.count(foe)
+
+        score = 0.0
+        for row in range(SIZE):
+            for col in range(SIZE):
+                cell = board.get(row, col)
+                if cell == me:
+                    score += _POSITION_WEIGHTS[row * SIZE + col]
+                elif cell == foe:
+                    score -= _POSITION_WEIGHTS[row * SIZE + col]
+
+        if self.config["mobility"]:
+            my_moves = len(board.legal_moves(me))
+            foe_moves = len(board.legal_moves(foe))
+            score += (my_moves - foe_moves) * 8
+
+            my_corners = sum(1 for r, c in _CORNERS if board.get(r, c) == me)
+            foe_corners = sum(1 for r, c in _CORNERS if board.get(r, c) == foe)
+            score += (my_corners - foe_corners) * 25
+
+        return score
+
+
+LEVEL_LABELS = {
+    1: "Lv.1 入門",
+    2: "Lv.2 初級",
+    3: "Lv.3 中級",
+    4: "Lv.4 上級",
+    5: "Lv.5 最強",
+}

cli_othello-0.1.0/src/cli_othello/board.py

@@ -0,0 +1,103 @@
+"""Othello board representation and rules."""
+
+from __future__ import annotations
+
+SIZE = 8
+EMPTY = 0
+BLACK = 1
+WHITE = 2
+
+DIRECTIONS = [
+    (-1, -1), (-1, 0), (-1, 1),
+    (0, -1), (0, 1),
+    (1, -1), (1, 0), (1, 1),
+]
+
+
+def opponent(player: int) -> int:
+    return WHITE if player == BLACK else BLACK
+
+
+class Board:
+    """8x8 Othello board. Cells are stored as a flat list of length 64."""
+
+    def __init__(self) -> None:
+        self.cells = [EMPTY] * (SIZE * SIZE)
+        mid = SIZE // 2
+        self.cells[(mid - 1) * SIZE + (mid - 1)] = WHITE
+        self.cells[(mid - 1) * SIZE + mid] = BLACK
+        self.cells[mid * SIZE + (mid - 1)] = BLACK
+        self.cells[mid * SIZE + mid] = WHITE
+
+    def clone(self) -> "Board":
+        new = Board.__new__(Board)
+        new.cells = list(self.cells)
+        return new
+
+    @staticmethod
+    def in_bounds(row: int, col: int) -> bool:
+        return 0 <= row < SIZE and 0 <= col < SIZE
+
+    def get(self, row: int, col: int) -> int:
+        return self.cells[row * SIZE + col]
+
+    def set(self, row: int, col: int, value: int) -> None:
+        self.cells[row * SIZE + col] = value
+
+    def _flips_for_move(self, row: int, col: int, player: int) -> list[tuple[int, int]]:
+        if self.get(row, col) != EMPTY:
+            return []
+        rival = opponent(player)
+        flips: list[tuple[int, int]] = []
+        for dr, dc in DIRECTIONS:
+            line: list[tuple[int, int]] = []
+            r, c = row + dr, col + dc
+            while self.in_bounds(r, c) and self.get(r, c) == rival:
+                line.append((r, c))
+                r, c = r + dr, c + dc
+            if line and self.in_bounds(r, c) and self.get(r, c) == player:
+                flips.extend(line)
+        return flips
+
+    def legal_moves(self, player: int) -> list[tuple[int, int]]:
+        moves = []
+        for row in range(SIZE):
+            for col in range(SIZE):
+                if self._flips_for_move(row, col, player):
+                    moves.append((row, col))
+        return moves
+
+    def has_legal_move(self, player: int) -> bool:
+        for row in range(SIZE):
+            for col in range(SIZE):
+                if self._flips_for_move(row, col, player):
+                    return True
+        return False
+
+    def play(self, row: int, col: int, player: int) -> bool:
+        flips = self._flips_for_move(row, col, player)
+        if not flips:
+            return False
+        self.set(row, col, player)
+        for r, c in flips:
+            self.set(r, c, player)
+        return True
+
+    def count(self, player: int) -> int:
+        return self.cells.count(player)
+
+    def is_full(self) -> bool:
+        return EMPTY not in self.cells
+
+    def is_game_over(self) -> bool:
+        if self.is_full():
+            return True
+        return not self.has_legal_move(BLACK) and not self.has_legal_move(WHITE)
+
+    def winner(self) -> int | None:
+        black, white = self.count(BLACK), self.count(WHITE)
+        if black > white:
+            return BLACK
+        if white > black:
+            return WHITE
+        return None

cli_othello-0.1.0/src/cli_othello/cli.py

@@ -0,0 +1,44 @@
+"""Command-line entry point for cli-othello."""
+
+from __future__ import annotations
+
+import argparse
+import curses
+
+from . import __version__
+from .ai import MAX_LEVEL, MIN_LEVEL
+from .ui import init_colors, play_game, select_level
+from .board import BLACK
+
+
+def _run(stdscr: "curses._CursesWindow", level: int | None) -> None:
+    init_colors()
+    chosen_level = level if level is not None else select_level(stdscr)
+    play_game(stdscr, human_player=BLACK, ai_level=chosen_level)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="othello",
+        description="Play Othello (Reversi) in your terminal against a 5-level AI.",
+    )
+    parser.add_argument(
+        "-l",
+        "--level",
+        type=int,
+        choices=range(MIN_LEVEL, MAX_LEVEL + 1),
+        help="AIの強さを指定して直接対局を開始する (1-5)。省略すると選択画面が表示されます。",
+    )
+    parser.add_argument(
+        "-V", "--version", action="version", version=f"cli-othello {__version__}"
+    )
+    args = parser.parse_args()
+
+    try:
+        curses.wrapper(_run, args.level)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

cli_othello-0.1.0/src/cli_othello/ui.py

@@ -0,0 +1,194 @@
+"""curses-based terminal UI for cli-othello."""
+
+from __future__ import annotations
+
+import curses
+
+from .ai import LEVEL_LABELS, MAX_LEVEL, MIN_LEVEL, OthelloAI
+from .board import BLACK, EMPTY, SIZE, WHITE, Board, opponent
+
+DISC_CHARS = {EMPTY: " ", BLACK: "●", WHITE: "○"}
+PLAYER_NAMES = {BLACK: "黒", WHITE: "白"}
+
+COLOR_BOARD = 1
+COLOR_BLACK = 2
+COLOR_WHITE = 3
+COLOR_CURSOR = 4
+COLOR_HINT = 5
+COLOR_HEADER = 6
+COLOR_STATUS = 7
+
+
+def init_colors() -> None:
+    curses.start_color()
+    curses.use_default_colors()
+    curses.init_pair(COLOR_BOARD, curses.COLOR_WHITE, curses.COLOR_GREEN)
+    curses.init_pair(COLOR_BLACK, curses.COLOR_BLACK, curses.COLOR_GREEN)
+    curses.init_pair(COLOR_WHITE, curses.COLOR_WHITE, curses.COLOR_GREEN)
+    curses.init_pair(COLOR_CURSOR, curses.COLOR_BLACK, curses.COLOR_YELLOW)
+    curses.init_pair(COLOR_HINT, curses.COLOR_GREEN, curses.COLOR_BLACK)
+    curses.init_pair(COLOR_HEADER, curses.COLOR_CYAN, -1)
+    curses.init_pair(COLOR_STATUS, curses.COLOR_YELLOW, -1)
+
+
+def select_level(stdscr: "curses._CursesWindow") -> int:
+    """Let the user pick an AI difficulty level (1-5) with arrow keys."""
+    level = 3
+    curses.curs_set(0)
+    while True:
+        stdscr.erase()
+        stdscr.addstr(1, 2, "CLI OTHELLO", curses.color_pair(COLOR_HEADER) | curses.A_BOLD)
+        stdscr.addstr(3, 2, "対戦するAIの強さを選んでください", curses.color_pair(COLOR_HEADER))
+        for i in range(MIN_LEVEL, MAX_LEVEL + 1):
+            label = LEVEL_LABELS[i]
+            attr = curses.A_REVERSE | curses.A_BOLD if i == level else curses.A_NORMAL
+            stdscr.addstr(5 + i, 4, f"{label}", attr)
+        stdscr.addstr(
+            5 + MAX_LEVEL + 2,
+            2,
+            "↑/↓ で選択、Enter で決定、q で終了",
+            curses.color_pair(COLOR_STATUS),
+        )
+        stdscr.refresh()
+
+        key = stdscr.getch()
+        if key in (curses.KEY_UP, ord("k")):
+            level = MIN_LEVEL if level <= MIN_LEVEL else level - 1
+        elif key in (curses.KEY_DOWN, ord("j")):
+            level = MAX_LEVEL if level >= MAX_LEVEL else level + 1
+        elif key in (curses.KEY_ENTER, 10, 13):
+            return level
+        elif key in (ord("q"), ord("Q")):
+            raise SystemExit(0)
+
+
+def _draw_board(
+    stdscr: "curses._CursesWindow",
+    board: Board,
+    cursor: tuple[int, int],
+    legal: set[tuple[int, int]],
+    human_player: int,
+    ai_level: int,
+    message: str,
+    top: int = 0,
+) -> None:
+    stdscr.erase()
+    stdscr.addstr(top, 2, "CLI OTHELLO", curses.color_pair(COLOR_HEADER) | curses.A_BOLD)
+    stdscr.addstr(
+        top,
+        16,
+        f"AI: {LEVEL_LABELS[ai_level]}  あなた: {DISC_CHARS[human_player]}{PLAYER_NAMES[human_player]}",
+        curses.color_pair(COLOR_STATUS),
+    )
+
+    board_top = top + 2
+    board_left = 4
+
+    stdscr.addstr(board_top, board_left + 2, "  ".join("ABCDEFGH"))
+    for row in range(SIZE):
+        stdscr.addstr(board_top + 1 + row, board_left, f"{row + 1} ")
+        for col in range(SIZE):
+            cell = board.get(row, col)
+            char = DISC_CHARS[cell]
+            x = board_left + 2 + col * 3
+            y = board_top + 1 + row
+
+            if (row, col) == cursor:
+                attr = curses.color_pair(COLOR_CURSOR) | curses.A_BOLD
+            elif cell == BLACK:
+                attr = curses.color_pair(COLOR_BLACK) | curses.A_BOLD
+            elif cell == WHITE:
+                attr = curses.color_pair(COLOR_WHITE) | curses.A_BOLD
+            else:
+                attr = curses.color_pair(COLOR_BOARD)
+
+            display = char
+            if cell == EMPTY and (row, col) in legal:
+                display = "·"
+                if (row, col) != cursor:
+                    attr = curses.color_pair(COLOR_HINT)
+
+            stdscr.addstr(y, x, f" {display} ", attr)
+
+    score_y = board_top + SIZE + 2
+    stdscr.addstr(
+        score_y,
+        board_left,
+        f"● 黒: {board.count(BLACK)}    ○ 白: {board.count(WHITE)}",
+        curses.A_BOLD,
+    )
+    stdscr.addstr(score_y + 2, board_left, message, curses.color_pair(COLOR_STATUS))
+    stdscr.addstr(
+        score_y + 3,
+        board_left,
+        "矢印キー: 移動  Enter/Space: 着手  q: 終了",
+        curses.color_pair(COLOR_STATUS),
+    )
+    stdscr.refresh()
+
+
+def play_game(stdscr: "curses._CursesWindow", human_player: int, ai_level: int) -> None:
+    curses.curs_set(0)
+    board = Board()
+    ai_player = opponent(human_player)
+    ai = OthelloAI(ai_player, ai_level)
+    cursor = [3, 3]
+    turn = BLACK
+    message = ""
+
+    while True:
+        if board.is_game_over():
+            break
+
+        legal = set(board.legal_moves(turn))
+        if not legal:
+            message = f"{PLAYER_NAMES[turn]}はパスしました"
+            turn = opponent(turn)
+            continue
+
+        if turn == human_player:
+            message = "あなたの番です"
+            _draw_board(stdscr, board, tuple(cursor), legal, human_player, ai_level, message)
+            key = stdscr.getch()
+            if key in (curses.KEY_UP, ord("k")):
+                cursor[0] = (cursor[0] - 1) % SIZE
+            elif key in (curses.KEY_DOWN, ord("j")):
+                cursor[0] = (cursor[0] + 1) % SIZE
+            elif key in (curses.KEY_LEFT, ord("h")):
+                cursor[1] = (cursor[1] - 1) % SIZE
+            elif key in (curses.KEY_RIGHT, ord("l")):
+                cursor[1] = (cursor[1] + 1) % SIZE
+            elif key in (curses.KEY_ENTER, 10, 13, ord(" ")):
+                if tuple(cursor) in legal:
+                    board.play(cursor[0], cursor[1], turn)
+                    turn = opponent(turn)
+                else:
+                    message = "そこには置けません"
+            elif key in (ord("q"), ord("Q")):
+                return
+        else:
+            message = "AIが考えています…"
+            _draw_board(stdscr, board, tuple(cursor), legal, human_player, ai_level, message)
+            move = ai.choose_move(board)
+            if move is not None:
+                board.play(*move, turn)
+            turn = opponent(turn)
+
+    winner = board.winner()
+    if winner is None:
+        result = "引き分けです"
+    elif winner == human_player:
+        result = "あなたの勝ちです！"
+    else:
+        result = "AIの勝ちです"
+    _draw_board(stdscr, board, tuple(cursor), set(), human_player, ai_level, result)
+    stdscr.addstr(
+        SIZE + 8,
+        4,
+        "何かキーを押すと終了します",
+        curses.color_pair(COLOR_STATUS),
+    )
+    stdscr.refresh()
+    stdscr.getch()
+
+

cli_othello-0.1.0/src/cli_othello.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: cli-othello
+Version: 0.1.0
+Summary: Play Othello (Reversi) in your terminal against a 5-level AI
+Author-email: Lapius7 <20071209ryo@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Lapius7/cli-othello
+Project-URL: Repository, https://github.com/Lapius7/cli-othello
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: windows-curses; platform_system == "Windows"
+
+# cli-othello
+
+ターミナルでオセロ（リバーシ）を楽しめるCLIパッケージです。
+5段階の強さから選べるAIと対局できます。
+
+## インストール
+
+```bash
+pip install cli-othello
+```
+
+## 使い方
+
+```bash
+othello
+```
+
+起動すると対局前にAIの強さ（Lv.1〜Lv.5）を選ぶ画面が表示されます。
+強さを指定して直接対局を始めることもできます。
+
+```bash
+othello --level 3
+```
+
+### 操作方法
+
+| キー | 動作 |
+| --- | --- |
+| ↑ / ↓ / ← / → （または h/j/k/l） | カーソル移動 |
+| Enter / Space | カーソル位置に着手 |
+| q | 終了 |
+
+盤面では、自分が置ける場所が緑色の `·` でハイライトされます。
+
+## AIの強さ
+
+| レベル | 特徴 |
+| --- | --- |
+| Lv.1 入門 | ランダム性が高く、ほぼ気の向くままに着手 |
+| Lv.2 初級 | 浅い探索＋盤面の位置評価を考慮 |
+| Lv.3 中級 | 角・辺の重要度や着手可能数（機動力）も評価 |
+| Lv.4 上級 | より深く先読みしつつ盤面を評価 |
+| Lv.5 最強 | 深い探索（最大6手先）で最も精度高く着手を選択 |
+
+内部的にはミニマックス法とアルファベータ枝刈りを用い、レベルごとに探索の深さと評価関数の精度を変化させています。
+
+## 必要環境
+
+- Python 3.9以上
+- Windowsの場合は `windows-curses` が自動的に依存関係としてインストールされます
+
+## ライセンス
+
+MIT

cli_othello-0.1.0/src/cli_othello.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/cli_othello/__init__.py
+src/cli_othello/ai.py
+src/cli_othello/board.py
+src/cli_othello/cli.py
+src/cli_othello/ui.py
+src/cli_othello.egg-info/PKG-INFO
+src/cli_othello.egg-info/SOURCES.txt
+src/cli_othello.egg-info/dependency_links.txt
+src/cli_othello.egg-info/entry_points.txt
+src/cli_othello.egg-info/requires.txt
+src/cli_othello.egg-info/top_level.txt

cli_othello-0.1.0/src/cli_othello.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cli_othello-0.1.0/src/cli_othello.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+othello = cli_othello.cli:main

cli_othello-0.1.0/src/cli_othello.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[:platform_system == "Windows"]
+windows-curses

cli_othello-0.1.0/src/cli_othello.egg-info/top_level.txt

@@ -0,0 +1 @@
+cli_othello