supernovattt 1.0.0__tar.gz

supernovattt-1.0.0/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+
+Copyright (c) 2026 Supernova
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

supernovattt-1.0.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: supernovattt
+Version: 1.0.0
+Summary: A simple Python Tic Tac Toe game with a Supernova AI bot
+Author: Supernova
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Games/Entertainment :: Board Games
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Supernova TTT
+
+A simple Tic Tac Toe game against the Supernova AI bot.
+
+## Install
+
+```bash
+pip install supernovattt
+```
+
+## Play
+
+```python
+from supernovattt import play
+
+play("easy")
+```
+
+Available levels: `easy`, `medium`, `hard`, `impossible`.
+
+Default difficulty:
+
+```python
+play()
+```
+
+The bot uses Minimax with alpha-beta pruning for optimal play
+on the impossible difficulty.

supernovattt-1.0.0/README.md

@@ -0,0 +1,28 @@
+# Supernova TTT
+
+A simple Tic Tac Toe game against the Supernova AI bot.
+
+## Install
+
+```bash
+pip install supernovattt
+```
+
+## Play
+
+```python
+from supernovattt import play
+
+play("easy")
+```
+
+Available levels: `easy`, `medium`, `hard`, `impossible`.
+
+Default difficulty:
+
+```python
+play()
+```
+
+The bot uses Minimax with alpha-beta pruning for optimal play
+on the impossible difficulty.

supernovattt-1.0.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "supernovattt"
+version = "1.0.0"
+description = "A simple Python Tic Tac Toe game with a Supernova AI bot"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{name = "Supernova"}]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Games/Entertainment :: Board Games",
+]
+
+[tool.setuptools.packages.find]
+include = ["supernovattt*"]

supernovattt-1.0.0/setup.cfg

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

supernovattt-1.0.0/supernovattt/__init__.py

@@ -0,0 +1,6 @@
+"""Supernova Tic Tac Toe: a simple Python game-playing bot."""
+
+from .brain import play, choose_move, best_moves, check_winner
+
+__all__ = ["play", "choose_move", "best_moves", "check_winner"]
+__version__ = "1.0.0"

supernovattt-1.0.0/supernovattt/brain.py

@@ -0,0 +1,162 @@
+import random
+from math import inf
+
+EMPTY = " "
+HUMAN = "X"
+BOT = "O"
+
+WIN_LINES = (
+    (0, 1, 2), (3, 4, 5), (6, 7, 8),
+    (0, 3, 6), (1, 4, 7), (2, 5, 8),
+    (0, 4, 8), (2, 4, 6),
+)
+
+DIFFICULTIES = ("easy", "medium", "hard", "impossible")
+MOVE_ORDER = (4, 0, 2, 6, 8, 1, 3, 5, 7)
+
+
+def check_winner(board):
+    for a, b, c in WIN_LINES:
+        if board[a] != EMPTY and board[a] == board[b] == board[c]:
+            return board[a]
+    return None
+
+
+def legal_moves(board):
+    return [i for i, cell in enumerate(board) if cell == EMPTY]
+
+
+def terminal_score(board, depth):
+    result = check_winner(board)
+    if result == BOT:
+        return 10 - depth
+    if result == HUMAN:
+        return depth - 10
+    if not legal_moves(board):
+        return 0
+    return None
+
+
+def minimax(board, bot_turn, depth=0, alpha=-inf, beta=inf):
+    score = terminal_score(board, depth)
+    if score is not None:
+        return score
+
+    if bot_turn:
+        best = -inf
+        for move in MOVE_ORDER:
+            if board[move] != EMPTY:
+                continue
+            board[move] = BOT
+            score = minimax(board, False, depth + 1, alpha, beta)
+            board[move] = EMPTY
+            best = max(best, score)
+            alpha = max(alpha, best)
+            if alpha >= beta:
+                break
+        return best
+
+    best = inf
+    for move in MOVE_ORDER:
+        if board[move] != EMPTY:
+            continue
+        board[move] = HUMAN
+        score = minimax(board, True, depth + 1, alpha, beta)
+        board[move] = EMPTY
+        best = min(best, score)
+        beta = min(beta, best)
+        if alpha >= beta:
+            break
+    return best
+
+
+def best_moves(board):
+    scored = []
+    for move in legal_moves(board):
+        board[move] = BOT
+        score = minimax(board, False, 1, -inf, inf)
+        board[move] = EMPTY
+        scored.append((move, score))
+
+    if not scored:
+        return []
+
+    top = max(score for _, score in scored)
+    return [move for move, score in scored if score == top]
+
+
+def choose_move(board, difficulty="impossible"):
+    difficulty = difficulty.lower()
+    if difficulty not in DIFFICULTIES:
+        raise ValueError(f"Choose one of: {', '.join(DIFFICULTIES)}")
+    if len(board) != 9:
+        raise ValueError("Board must contain exactly 9 cells.")
+    if any(c not in (EMPTY, HUMAN, BOT) for c in board):
+        raise ValueError("Cells must be X, O, or a space.")
+    if check_winner(board):
+        raise ValueError("The game has already ended.")
+
+    moves = legal_moves(board)
+    if not moves:
+        return None
+
+    if difficulty == "easy":
+        return random.choice(best_moves(board)) if random.random() < 0.2 else random.choice(moves)
+    if difficulty == "medium":
+        return random.choice(best_moves(board)) if random.random() < 0.5 else random.choice(moves)
+    if difficulty == "hard":
+        return random.choice(best_moves(board)) if random.random() < 0.9 else random.choice(moves)
+
+    return random.choice(best_moves(board))
+
+
+def play(difficulty="impossible"):
+    difficulty = difficulty.lower()
+    if difficulty not in DIFFICULTIES:
+        raise ValueError(f"Choose one of: {', '.join(DIFFICULTIES)}")
+
+    board = [EMPTY] * 9
+    print(f"=== SUPERNOVA TTT | {difficulty.upper()} ===")
+    print("You are X. Supernova is O. Enter 1-9, or q to quit.")
+
+    while True:
+        print()
+        for row in range(3):
+            print(" " + " | ".join(
+                board[row * 3 + col] if board[row * 3 + col] != EMPTY
+                else str(row * 3 + col + 1)
+                for col in range(3)
+            ))
+            if row < 2:
+                print("---+---+---")
+
+        result = check_winner(board)
+        if result:
+            print("Supernova wins!" if result == BOT else "You win!")
+            return result
+        if not legal_moves(board):
+            print("Draw!")
+            return "draw"
+
+        choice = input("\nYour move: ").strip().lower()
+        if choice == "q":
+            print("Game ended.")
+            return None
+
+        try:
+            move = int(choice) - 1
+        except ValueError:
+            print("Enter a number from 1 to 9.")
+            continue
+
+        if move not in range(9) or board[move] != EMPTY:
+            print("Invalid or occupied square.")
+            continue
+
+        board[move] = HUMAN
+        if check_winner(board) or not legal_moves(board):
+            continue
+
+        bot_move = choose_move(board, difficulty)
+        board[bot_move] = BOT
+        print(f"Supernova chose square {bot_move + 1}.")

supernovattt-1.0.0/supernovattt.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: supernovattt
+Version: 1.0.0
+Summary: A simple Python Tic Tac Toe game with a Supernova AI bot
+Author: Supernova
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Games/Entertainment :: Board Games
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Supernova TTT
+
+A simple Tic Tac Toe game against the Supernova AI bot.
+
+## Install
+
+```bash
+pip install supernovattt
+```
+
+## Play
+
+```python
+from supernovattt import play
+
+play("easy")
+```
+
+Available levels: `easy`, `medium`, `hard`, `impossible`.
+
+Default difficulty:
+
+```python
+play()
+```
+
+The bot uses Minimax with alpha-beta pruning for optimal play
+on the impossible difficulty.

supernovattt-1.0.0/supernovattt.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+supernovattt/__init__.py
+supernovattt/brain.py
+supernovattt.egg-info/PKG-INFO
+supernovattt.egg-info/SOURCES.txt
+supernovattt.egg-info/dependency_links.txt
+supernovattt.egg-info/top_level.txt

supernovattt-1.0.0/supernovattt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

supernovattt-1.0.0/supernovattt.egg-info/top_level.txt

@@ -0,0 +1 @@
+supernovattt