Upload 3 files

app.py

@@ -0,0 +1,186 @@
+# app.py
+import os
+import base64
+import gradio as gr
+import chess
+import chess.svg
+import chess.engine
+
+# -------- Engine-config --------
+STOCKFISH_PATH = "stockfish"  # dankzij apt.txt staat de binary in PATH
+
+DEFAULT_THREADS = max(1, os.cpu_count() or 2)
+DEFAULT_HASH_MB = 512        # pas gerust omhoog aan als je Space genoeg RAM heeft
+DEFAULT_MOVETIME_MS = 1500   # engine denktijd per zet
+
+# -------- Helpers --------
+def board_svg(board: chess.Board, last_move=None) -> str:
+    """Geef een SVG-string van het bord terug."""
+    return chess.svg.board(
+        board=board,
+        lastmove=last_move,
+        check=board.is_check(),
+        coordinates=True,
+        size=480,
+    )
+
+def svg_to_data_url(svg_text: str) -> str:
+    """Returneer data-URL van SVG (zodat Gradio 'm kan tonen in HTML)."""
+    b64 = base64.b64encode(svg_text.encode("utf-8")).decode("ascii")
+    return f"data:image/svg+xml;base64,{b64}"
+
+def new_engine(threads=DEFAULT_THREADS, hash_mb=DEFAULT_HASH_MB, ponder=False):
+    engine = chess.engine.SimpleEngine.popen_uci(STOCKFISH_PATH)
+    # Sterke UCI-opts
+    opts = {
+        "Threads": int(threads),
+        "Hash": int(hash_mb),
+        "UCI_LimitStrength": False,
+        "Skill Level": 20,
+        "Ponder": ponder,
+        "Move Overhead": 30,
+    }
+    try:
+        engine.configure(opts)
+    except Exception as e:
+        print("UCI-opties zetten gaf een fout (doorgaan):", e)
+    return engine
+
+# -------- Gradio statestructuur --------
+def init_state(engine_color: str, movetime_ms: int, depth: int | None, threads: int, hash_mb: int):
+    board = chess.Board()
+    engine = new_engine(threads=threads, hash_mb=hash_mb)
+    state = {
+        "board": board,
+        "engine": engine,
+        "engine_color": engine_color,  # "white" or "black"
+        "movetime_ms": movetime_ms,
+        "depth": depth if depth and depth > 0 else None,
+        "last_move": None,
+    }
+    # Als engine wit is, laat ‘m meteen zetten
+    if engine_color == "white":
+        _ = engine_move(state)
+    return state
+
+def engine_limit(state):
+    if state["depth"] is not None:
+        return chess.engine.Limit(depth=int(state["depth"]))
+    return chess.engine.Limit(time=max(0.05, state["movetime_ms"]/1000.0))
+
+def render(state):
+    svg = board_svg(state["board"], last_move=state["last_move'])
+    return svg_to_data_url(svg), state["board"].fen()
+
+# -------- Acties --------
+def new_game(engine_color, movetime_ms, depth, threads, hash_mb):
+    state = init_state(engine_color, int(movetime_ms), int(depth) if depth else None, int(threads), int(hash_mb))
+    img, fen = render(state)
+    return state, img, fen, "Nieuwe partij gestart."
+
+def make_move(state, user_move):
+    board: chess.Board = state["board"]
+    if board.is_game_over():
+        return state, *render(state), f"Partij is al afgelopen: {board.result()}."
+
+    try:
+        # UCI notatie (b.v. e2e4 of e7e8q)
+        mv = chess.Move.from_uci(user_move.strip())
+        if mv not in board.legal_moves:
+            return state, *render(state), "Ongeldige zet (niet legaal in deze stelling)."
+        board.push(mv)
+        state["last_move"] = mv
+    except Exception as e:
+        return state, *render(state), f"Ongeldige invoer: {e}"
+
+    if board.is_game_over():
+        img, fen = render(state)
+        return state, img, fen, f"Partij afgelopen: {board.result()}."
+
+    # engine aan zet?
+    side_to_move = "white" if board.turn == chess.WHITE else "black"
+    if side_to_move == state["engine_color"]:
+        msg = engine_move(state)
+    else:
+        msg = "Jij bent aan zet."
+    img, fen = render(state)
+    return state, img, fen, msg
+
+def engine_move(state):
+    board: chess.Board = state["board"]
+    engine: chess.engine.SimpleEngine = state["engine"]
+    if board.is_game_over():
+        return f"Partij afgelopen: {board.result()}."
+    try:
+        result = engine.play(board, engine_limit(state))
+        board.push(result.move)
+        state["last_move"] = result.move
+        if board.is_game_over():
+            return f"Engine zet {result.move}. Partij afgelopen: {board.result()}."
+        else:
+            return f"Engine zet {result.move}. Jij bent aan zet."
+    except Exception as e:
+        return f"Engine-fout: {e}"
+
+def undo_move(state):
+    board: chess.Board = state["board"]
+    if len(board.move_stack) == 0:
+        return state, *render(state), "Geen zetten om terug te nemen."
+    # Neem 1 of 2 zetten terug zodat jij weer aan zet bent
+    board.pop()
+    if state["engine_color"] == ("white" if board.turn == chess.WHITE else "black") and len(board.move_stack) > 0:
+        board.pop()
+    state["last_move"] = board.move_stack[-1] if board.move_stack else None
+    return state, *render(state), "Zet(ten) teruggenomen."
+
+def resign(state):
+    board: chess.Board = state["board"]
+    outcome = "1-0" if board.turn == chess.BLACK else "0-1"
+    return state, *render(state), f"Opgegeven. Resultaat: {outcome}"
+
+def stop_engine(state):
+    try:
+        state["engine"].quit()
+    except Exception:
+        pass
+    return "Engine gestopt."
+
+# -------- Gradio UI --------
+with gr.Blocks(title="Boss Chess (Stockfish)") as demo:
+    gr.Markdown("# ♟️ Boss Chess (Stockfish)\nSpeel tegen een sterke NNUE-engine (Stockfish) in je browser.")
+
+    with gr.Row():
+        board_html = gr.HTML(label="Bord")
+        fen_out = gr.Textbox(label="FEN", interactive=False)
+
+    with gr.Row():
+        user_move = gr.Textbox(label="Jouw zet (UCI, bv. e2e4)", placeholder="e2e4", scale=2)
+        btn_move = gr.Button("Zet uitvoeren", variant="primary")
+        btn_undo = gr.Button("Undo")
+        btn_resign = gr.Button("Resign")
+
+    status = gr.Markdown("Klaar.")
+
+    with gr.Accordion("⚙️ Instellingen", open=False):
+        engine_color = gr.Radio(choices=["white","black"], value="black", label="Engine kleur")
+        movetime = gr.Slider(200, 5000, value=DEFAULT_MOVETIME_MS, step=100, label="Engine denktijd (ms/zet)")
+        depth = gr.Slider(0, 30, value=0, step=1, label="Max diepte (0=uit)")
+        threads = gr.Slider(1, DEFAULT_THREADS, value=DEFAULT_THREADS, step=1, label="Threads")
+        hash_mb = gr.Slider(64, 2048, value=DEFAULT_HASH_MB, step=64, label="Hash (MB)")
+        btn_new = gr.Button("Nieuwe partij / herstart")
+
+    state = gr.State()
+
+    # Callbacks
+    btn_new.click(new_game, [engine_color, movetime, depth, threads, hash_mb],
+                  [state, board_html, fen_out, status])
+    btn_move.click(make_move, [state, user_move], [state, board_html, fen_out, status])
+    btn_undo.click(undo_move, [state], [state, board_html, fen_out, status])
+    btn_resign.click(resign, [state], [state, board_html, fen_out, status])
+
+    # Auto-start een partij
+    demo.load(new_game, [engine_color, movetime, depth, threads, hash_mb],
+              [state, board_html, fen_out, status])
+
+if __name__ == "__main__":
+    demo.launch()

apt.txt

@@ -0,0 +1 @@
+stockfish

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=4.31
+python-chess>=1.999