first commit

app.py

@@ -0,0 +1,436 @@
+import json
+import random
+import sqlite3
+import uuid
+from pathlib import Path
+
+from flask import Flask, g, jsonify, render_template, request, session
+
+BASE_DIR = Path(__file__).resolve().parent
+DB_PATH = BASE_DIR / "schiffe_versenken.db"
+BOARD_SIZE = 10
+
+FLEET = [
+    {"id": "koenig", "name": "Zwergenkönig", "size": 5, "hat": "#c0392b"},
+    {"id": "hauptmann", "name": "Zwergenhauptmann", "size": 4, "hat": "#2980b9"},
+    {"id": "krieger1", "name": "Zwergenkrieger I", "size": 3, "hat": "#27ae60"},
+    {"id": "krieger2", "name": "Zwergenkrieger II", "size": 3, "hat": "#8e44ad"},
+    {"id": "kundschafter", "name": "Zwergenkundschafter", "size": 2, "hat": "#d35400"},
+]
+FLEET_BY_ID = {s["id"]: s for s in FLEET}
+
+app = Flask(__name__)
+app.secret_key = "zwerge-schiffe-versenken-" + uuid.uuid4().hex
+
+
+def get_db():
+    if "db" not in g:
+        g.db = sqlite3.connect(DB_PATH)
+        g.db.row_factory = sqlite3.Row
+    return g.db
+
+
+@app.teardown_appcontext
+def close_db(exception=None):
+    db = g.pop("db", None)
+    if db is not None:
+        db.close()
+
+
+def init_db():
+    conn = sqlite3.connect(DB_PATH)
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS games (
+            id TEXT PRIMARY KEY,
+            player_board TEXT NOT NULL,
+            computer_board TEXT NOT NULL,
+            player_shots TEXT NOT NULL,
+            computer_shots TEXT NOT NULL,
+            computer_ai_state TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'placing',
+            message TEXT DEFAULT '',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+        """
+    )
+    conn.commit()
+    conn.close()
+
+
+def empty_grid():
+    return [[None for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
+
+
+def empty_shots():
+    return [[None for _ in range(BOARD_SIZE)] for _ in range(BOARD_SIZE)]
+
+
+def can_place(grid, row, col, size, orientation):
+    cells = ship_cells(row, col, size, orientation)
+    for r, c in cells:
+        if not (0 <= r < BOARD_SIZE and 0 <= c < BOARD_SIZE):
+            return False
+        if grid[r][c] is not None:
+            return False
+    return True
+
+
+def ship_cells(row, col, size, orientation):
+    if orientation == "h":
+        return [(row, col + i) for i in range(size)]
+    return [(row + i, col) for i in range(size)]
+
+
+def place_ship(grid, ship_id, row, col, size, orientation):
+    for r, c in ship_cells(row, col, size, orientation):
+        grid[r][c] = ship_id
+
+
+def random_place_all_ships():
+    grid = empty_grid()
+    for ship in FLEET:
+        placed = False
+        attempts = 0
+        while not placed and attempts < 500:
+            attempts += 1
+            orientation = random.choice(["h", "v"])
+            row = random.randint(0, BOARD_SIZE - 1)
+            col = random.randint(0, BOARD_SIZE - 1)
+            if can_place(grid, row, col, ship["size"], orientation):
+                place_ship(grid, ship["id"], row, col, ship["size"], orientation)
+                placed = True
+        if not placed:
+            return random_place_all_ships()
+    return grid
+
+
+def new_game_row():
+    game_id = str(uuid.uuid4())
+    computer_board = random_place_all_ships()
+    row = {
+        "id": game_id,
+        "player_board": empty_grid(),
+        "computer_board": computer_board,
+        "player_shots": empty_shots(),
+        "computer_shots": empty_shots(),
+        "computer_ai_state": {"mode": "random", "targets": [], "tried": []},
+        "status": "placing",
+        "message": "Platziere deine Zwerge auf dem Spielfeld.",
+    }
+    db = get_db()
+    db.execute(
+        "INSERT INTO games (id, player_board, computer_board, player_shots, computer_shots, "
+        "computer_ai_state, status, message) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+        (
+            row["id"],
+            json.dumps(row["player_board"]),
+            json.dumps(row["computer_board"]),
+            json.dumps(row["player_shots"]),
+            json.dumps(row["computer_shots"]),
+            json.dumps(row["computer_ai_state"]),
+            row["status"],
+            row["message"],
+        ),
+    )
+    db.commit()
+    session["game_id"] = game_id
+    return load_game(game_id)
+
+
+def load_game(game_id):
+    db = get_db()
+    r = db.execute("SELECT * FROM games WHERE id = ?", (game_id,)).fetchone()
+    if r is None:
+        return None
+    return {
+        "id": r["id"],
+        "player_board": json.loads(r["player_board"]),
+        "computer_board": json.loads(r["computer_board"]),
+        "player_shots": json.loads(r["player_shots"]),
+        "computer_shots": json.loads(r["computer_shots"]),
+        "computer_ai_state": json.loads(r["computer_ai_state"]),
+        "status": r["status"],
+        "message": r["message"],
+    }
+
+
+def save_game(game):
+    db = get_db()
+    db.execute(
+        "UPDATE games SET player_board=?, computer_board=?, player_shots=?, computer_shots=?, "
+        "computer_ai_state=?, status=?, message=? WHERE id=?",
+        (
+            json.dumps(game["player_board"]),
+            json.dumps(game["computer_board"]),
+            json.dumps(game["player_shots"]),
+            json.dumps(game["computer_shots"]),
+            json.dumps(game["computer_ai_state"]),
+            game["status"],
+            game["message"],
+            game["id"],
+        ),
+    )
+    db.commit()
+
+
+def get_current_game():
+    game_id = session.get("game_id")
+    if not game_id:
+        return None
+    return load_game(game_id)
+
+
+def ship_is_sunk(board, shots, ship_id):
+    for r in range(BOARD_SIZE):
+        for c in range(BOARD_SIZE):
+            if board[r][c] == ship_id and shots[r][c] != "hit":
+                return False
+    return True
+
+
+def all_ships_sunk(board, shots):
+    ship_ids = {cell for row in board for cell in row if cell is not None}
+    return all(ship_is_sunk(board, shots, sid) for sid in ship_ids)
+
+
+def fleet_status(board, shots):
+    result = []
+    for ship in FLEET:
+        result.append(
+            {
+                "id": ship["id"],
+                "name": ship["name"],
+                "size": ship["size"],
+                "hat": ship["hat"],
+                "sunk": ship_is_sunk(board, shots, ship["id"]),
+            }
+        )
+    return result
+
+
+def neighbors(r, c):
+    for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):
+        nr, nc = r + dr, c + dc
+        if 0 <= nr < BOARD_SIZE and 0 <= nc < BOARD_SIZE:
+            yield nr, nc
+
+
+def computer_take_shot(game):
+    board = game["player_board"]
+    shots = game["computer_shots"]
+    ai = game["computer_ai_state"]
+
+    target = None
+    if ai["mode"] == "target" and ai["targets"]:
+        while ai["targets"]:
+            candidate = tuple(ai["targets"].pop(0))
+            if shots[candidate[0]][candidate[1]] is None:
+                target = candidate
+                break
+        if not ai["targets"] and target is None:
+            ai["mode"] = "random"
+
+    if target is None:
+        ai["mode"] = "random"
+        choices = [
+            (r, c)
+            for r in range(BOARD_SIZE)
+            for c in range(BOARD_SIZE)
+            if shots[r][c] is None
+        ]
+        target = random.choice(choices)
+
+    r, c = target
+    hit = board[r][c] is not None
+    shots[r][c] = "hit" if hit else "miss"
+
+    sunk_ship = None
+    if hit:
+        ship_id = board[r][c]
+        if ship_is_sunk(board, shots, ship_id):
+            sunk_ship = FLEET_BY_ID[ship_id]["name"]
+            ai["mode"] = "random"
+            ai["targets"] = []
+        else:
+            ai["mode"] = "target"
+            for nr, nc in neighbors(r, c):
+                if shots[nr][nc] is None and [nr, nc] not in ai["targets"]:
+                    ai["targets"].append([nr, nc])
+    game["computer_ai_state"] = ai
+    return {"row": r, "col": c, "hit": hit, "sunk_ship": sunk_ship}
+
+
+@app.route("/")
+def index():
+    game = get_current_game()
+    if game is None:
+        game = new_game_row()
+    return render_template("index.html", fleet=FLEET, board_size=BOARD_SIZE)
+
+
+@app.route("/api/state")
+def api_state():
+    game = get_current_game()
+    if game is None:
+        game = new_game_row()
+    return jsonify(build_state_payload(game))
+
+
+def build_state_payload(game):
+    return {
+        "status": game["status"],
+        "message": game["message"],
+        "player_board": game["player_board"],
+        "player_shots_received": game["computer_shots"],
+        "player_shots_made": game["player_shots"],
+        "player_fleet": fleet_status(game["player_board"], game["computer_shots"]),
+        "computer_fleet": fleet_status(game["computer_board"], game["player_shots"]),
+        "fleet_def": FLEET,
+        "board_size": BOARD_SIZE,
+    }
+
+
+@app.route("/api/new_game", methods=["POST"])
+def api_new_game():
+    game = new_game_row()
+    return jsonify(build_state_payload(game))
+
+
+@app.route("/api/place_ship", methods=["POST"])
+def api_place_ship():
+    game = get_current_game()
+    if game is None or game["status"] != "placing":
+        return jsonify({"error": "Kein aktives Platzierungsspiel."}), 400
+
+    data = request.get_json(force=True)
+    ship_id = data.get("ship_id")
+    row = data.get("row")
+    col = data.get("col")
+    orientation = data.get("orientation", "h")
+
+    ship = FLEET_BY_ID.get(ship_id)
+    if ship is None:
+        return jsonify({"error": "Unbekannter Zwerg."}), 400
+
+    board = game["player_board"]
+    already_placed = any(ship_id in row_ for row_ in board)
+    if already_placed:
+        return jsonify({"error": "Dieser Zwerg steht schon auf dem Feld."}), 400
+
+    if not can_place(board, row, col, ship["size"], orientation):
+        return jsonify({"error": "Hier passt der Zwerg nicht hin."}), 400
+
+    place_ship(board, ship_id, row, col, ship["size"], orientation)
+    game["player_board"] = board
+
+    placed_ids = {cell for row_ in board for cell in row_ if cell is not None}
+    if len(placed_ids) == len(FLEET):
+        game["message"] = "Alle Zwerge stehen bereit! Klicke auf 'Kampf beginnen'."
+    else:
+        game["message"] = f"{ship['name']} platziert."
+
+    save_game(game)
+    return jsonify(build_state_payload(game))
+
+
+@app.route("/api/random_place", methods=["POST"])
+def api_random_place():
+    game = get_current_game()
+    if game is None or game["status"] != "placing":
+        return jsonify({"error": "Kein aktives Platzierungsspiel."}), 400
+    game["player_board"] = random_place_all_ships()
+    game["message"] = "Alle Zwerge wurden zufällig aufgestellt."
+    save_game(game)
+    return jsonify(build_state_payload(game))
+
+
+@app.route("/api/reset_placement", methods=["POST"])
+def api_reset_placement():
+    game = get_current_game()
+    if game is None or game["status"] != "placing":
+        return jsonify({"error": "Kein aktives Platzierungsspiel."}), 400
+    game["player_board"] = empty_grid()
+    game["message"] = "Aufstellung zurückgesetzt."
+    save_game(game)
+    return jsonify(build_state_payload(game))
+
+
+@app.route("/api/start", methods=["POST"])
+def api_start():
+    game = get_current_game()
+    if game is None or game["status"] != "placing":
+        return jsonify({"error": "Kein aktives Platzierungsspiel."}), 400
+
+    placed_ids = {cell for row_ in game["player_board"] for cell in row_ if cell is not None}
+    if len(placed_ids) != len(FLEET):
+        return jsonify({"error": "Bitte alle Zwerge platzieren, bevor der Kampf beginnt."}), 400
+
+    game["status"] = "playing"
+    game["message"] = "Der Kampf hat begonnen! Du bist am Zug – ziehe in die feindlichen Berge."
+    save_game(game)
+    return jsonify(build_state_payload(game))
+
+
+@app.route("/api/fire", methods=["POST"])
+def api_fire():
+    game = get_current_game()
+    if game is None or game["status"] != "playing":
+        return jsonify({"error": "Das Spiel läuft gerade nicht."}), 400
+
+    data = request.get_json(force=True)
+    row, col = data.get("row"), data.get("col")
+    if row is None or col is None or not (0 <= row < BOARD_SIZE and 0 <= col < BOARD_SIZE):
+        return jsonify({"error": "Ungültiges Feld."}), 400
+
+    if game["player_shots"][row][col] is not None:
+        return jsonify({"error": "Dorthin hast du schon geschossen."}), 400
+
+    board = game["computer_board"]
+    shots = game["player_shots"]
+    hit = board[row][col] is not None
+    shots[row][col] = "hit" if hit else "miss"
+    game["player_shots"] = shots
+
+    player_result = {"row": row, "col": col, "hit": hit, "sunk_ship": None}
+    if hit:
+        ship_id = board[row][col]
+        if ship_is_sunk(board, shots, ship_id):
+            player_result["sunk_ship"] = FLEET_BY_ID[ship_id]["name"]
+
+    computer_result = None
+    if all_ships_sunk(game["computer_board"], game["player_shots"]):
+        game["status"] = "player_win"
+        game["message"] = "Sieg! Du hast alle Zwergensiedlungen des Computers zerstört."
+    else:
+        computer_result = computer_take_shot(game)
+        if all_ships_sunk(game["player_board"], game["computer_shots"]):
+            game["status"] = "computer_win"
+            game["message"] = "Niederlage! Der Computer hat all deine Zwerge besiegt."
+        else:
+            msgs = []
+            msgs.append(
+                f"Treffer bei {player_result['row']},{player_result['col']}!"
+                if player_result["hit"]
+                else "Daneben."
+            )
+            if player_result["sunk_ship"]:
+                msgs.append(f"{player_result['sunk_ship']} wurde versenkt!")
+            msgs.append(
+                "Der Computer trifft dich!" if computer_result["hit"] else "Der Computer schießt daneben."
+            )
+            if computer_result["sunk_ship"]:
+                msgs.append(f"Dein {computer_result['sunk_ship']} wurde versenkt!")
+            game["message"] = " ".join(msgs)
+
+    save_game(game)
+    payload = build_state_payload(game)
+    payload["player_shot"] = player_result
+    payload["computer_shot"] = computer_result
+    return jsonify(payload)
+
+
+init_db()
+
+if __name__ == "__main__":
+    app.run(debug=True, port=5000)