Update app.py

app.py

@@ -1,181 +1,133 @@
-from flask import Flask, render_template, request, jsonify, session
-from flask_session import Session # Pour gérer les sessions côté serveur si besoin de plus de complexité
-import chess
-import chess.svg
-from stockfish import Stockfish
+from flask import Flask, render_template, request, jsonify
+from stockfish import Stockfish, StockfishException
 import os
 
 app = Flask(__name__)
 
-# Configuration de la clé secrète pour les sessions Flask
-app.config["SECRET_KEY"] = os.urandom(24) # Ou une chaîne fixe pour le développement
+# --- Configuration Stockfish ---
+STOCKFISH_PATH = "/usr/games/stockfish"  # Modifiez selon votre installation
+# STOCKFISH_PATH = "/opt/homebrew/bin/stockfish"  # macOS
+# STOCKFISH_PATH = "stockfish"  # Si dans le PATH
 
-# Configuration pour Flask-Session (stocke les sessions côté serveur, ex: filesystem)
-# Ceci est optionnel pour cet exemple simple où FEN est petit, mais bon pour des états plus complexes.
-app.config["SESSION_PERMANENT"] = False
-app.config["SESSION_TYPE"] = "filesystem" # Peut être redis, memcached, etc.
-Session(app)
-
-# --- IMPORTANT : MODIFIEZ CE CHEMIN ---
-# Mettez le chemin absolu vers votre exécutable Stockfish
-# Exemples:
-# Windows: "C:\\Chemin\\Vers\\Stockfish\\stockfish_15.1_win_x64_avx2.exe"
-# macOS/Linux: "/usr/local/bin/stockfish" ou "./stockfish-ubuntu-x86-64-avx2"
-STOCKFISH_PATH = "/usr/local/bin/stockfish" # <--- MODIFIEZ CECI !
+STOCKFISH_DEPTH = 12
+STOCKFISH_PARAMS = {
+    "Threads": 2,
+    "Hash": 128,
+    "UCI_LimitStrength": False,
+    "Skill Level": 15  # Niveau modéré (0-20)
+}
 
+# Initialiser Stockfish
 try:
-    stockfish = Stockfish(path=STOCKFISH_PATH,
-                          depth=15, # Profondeur de recherche par défaut
-                          parameters={
-                              "Skill Level": 5, # Niveau de compétence (0-20)
-                              "Threads": 2, # Nombre de threads CPU à utiliser
-                              "Hash": 128 # Mémoire pour la table de transposition (en Mo)
-                          })
-    print(f"Stockfish initialisé avec succès. Version: {stockfish.get_stockfish_major_version()}")
+    sf = Stockfish(path=STOCKFISH_PATH, depth=STOCKFISH_DEPTH, parameters=STOCKFISH_PARAMS)
+    print(f"Stockfish initialisé: {sf._path}")
 except Exception as e:
-    print(f"ERREUR: Impossible d'initialiser Stockfish. Vérifiez le chemin: {STOCKFISH_PATH}")
-    print(f"Détail de l'erreur: {e}")
-    stockfish = None # Pour que l'app puisse démarrer même si SF échoue (mode IA sera désactivé)
+    print(f"Erreur Stockfish: {e}")
+    sf = None
 
 @app.route('/')
 def index():
-    """Affiche la page principale du jeu."""
-    # Initialiser un nouveau plateau si aucun n'existe dans la session
-    if 'board_fen' not in session:
-        board = chess.Board()
-        session['board_fen'] = board.fen()
-        session['game_mode'] = 'human' # ou 'ai'
-        session['player_color'] = chess.WHITE # Si l'humain joue les blancs contre l'IA
-    return render_template('index.html', initial_fen=session['board_fen'])
-
-@app.route('/new_game', methods=['POST'])
-def new_game():
-    """Commence une nouvelle partie."""
-    data = request.get_json()
-    mode = data.get('mode', 'human') # 'human' ou 'ai'
-    player_plays_white = data.get('player_color_white', True) # True si le joueur joue blanc
-
-    board = chess.Board()
-    session['board_fen'] = board.fen()
-    session['game_mode'] = mode
-    session['player_color'] = chess.WHITE if player_plays_white else chess.BLACK
-
-    ai_move_uci = None
-    ai_move_san = None
+    return render_template('index.html')
 
-    if mode == 'ai' and not player_plays_white: # L'IA joue les blancs (premier coup)
-        if stockfish:
-            stockfish.set_fen_position(board.fen())
-            best_move_uci = stockfish.get_best_move()
-            if best_move_uci:
-                move = chess.Move.from_uci(best_move_uci)
-                ai_move_san = board.san(move)
-                board.push(move)
-                session['board_fen'] = board.fen()
-                ai_move_uci = best_move_uci
-        else:
-            return jsonify({'error': 'Stockfish non disponible'}), 500
-
-    return jsonify({
-        'fen': board.fen(),
-        'board_svg': chess.svg.board(board=board, size=350),
-        'turn': 'Blanc' if board.turn == chess.WHITE else 'Noir',
-        'game_over': board.is_game_over(),
-        'status': get_game_status(board),
-        'ai_move_uci': ai_move_uci,
-        'ai_move_san': ai_move_san
-    })
-
-@app.route('/move', methods=['POST'])
+@app.route('/api/move', methods=['POST'])
 def make_move():
-    """Gère un coup du joueur et potentiellement la réponse de l'IA."""
-    if 'board_fen' not in session:
-        return jsonify({'error': 'Partie non initialisée. Commencez une nouvelle partie.'}), 400
-
-    board = chess.Board(session['board_fen'])
-    game_mode = session.get('game_mode', 'human')
-    player_color = session.get('player_color', chess.WHITE)
-
-    data = request.get_json()
-    move_uci = data.get('move') # ex: "e2e4"
-
-    if not move_uci:
-        return jsonify({'error': 'Aucun coup fourni'}), 400
-
-    player_move_san = None
+    if not sf:
+        return jsonify({'error': 'Stockfish non disponible'}), 500
+    
     try:
-        move = chess.Move.from_uci(move_uci)
-        if move in board.legal_moves:
-            player_move_san = board.san(move)
-            board.push(move)
-            session['board_fen'] = board.fen()
-        else:
-            return jsonify({'error': 'Coup illégal', 'fen': board.fen(), 'board_svg': chess.svg.board(board=board, size=350)}), 400
-    except ValueError:
-        return jsonify({'error': 'Format de coup invalide', 'fen': board.fen(), 'board_svg': chess.svg.board(board=board, size=350)}), 400
-
-    ai_move_uci = None
-    ai_move_san = None
-    game_over = board.is_game_over()
-    status = get_game_status(board)
-
-    if not game_over and game_mode == 'ai' and board.turn != player_color:
-        if stockfish:
-            stockfish.set_fen_position(board.fen())
-            best_move_ai_uci = stockfish.get_best_move_time(1000) # L'IA réfléchit max 1 seconde
-            if best_move_ai_uci:
-                ai_chess_move = chess.Move.from_uci(best_move_ai_uci)
-                ai_move_san = board.san(ai_chess_move)
-                board.push(ai_chess_move)
-                session['board_fen'] = board.fen()
-                ai_move_uci = best_move_ai_uci
-                game_over = board.is_game_over() # Vérifier à nouveau après le coup de l'IA
-                status = get_game_status(board)
-        else:
-            status = "Stockfish non disponible. L'IA ne peut pas jouer."
-
-
-    return jsonify({
-        'fen': board.fen(),
-        'board_svg': chess.svg.board(board=board, size=350, lastmove=move if not ai_move_uci else ai_chess_move),
-        'turn': 'Blanc' if board.turn == chess.WHITE else 'Noir',
-        'game_over': game_over,
-        'status': status,
-        'player_move_san': player_move_san,
-        'ai_move_uci': ai_move_uci,
-        'ai_move_san': ai_move_san,
-        'last_move_uci': move_uci if not ai_move_uci else ai_move_uci
-    })
-
-@app.route('/get_board_state')
-def get_board_state():
-    if 'board_fen' not in session:
-        return jsonify({'error': 'Partie non initialisée'}), 404
-    board = chess.Board(session['board_fen'])
-    return jsonify({
-        'fen': board.fen(),
-        'board_svg': chess.svg.board(board=board, size=350),
-        'turn': 'Blanc' if board.turn == chess.WHITE else 'Noir',
-        'game_over': board.is_game_over(),
-        'status': get_game_status(board)
-    })
-
-def get_game_status(board):
-    if board.is_checkmate():
-        return f"Échec et mat ! {'Les Noirs' if board.turn == chess.WHITE else 'Les Blancs'} gagnent."
-    if board.is_stalemate():
-        return "Pat ! Partie nulle."
-    if board.is_insufficient_material():
-        return "Matériel insuffisant. Partie nulle."
-    if board.is_seventyfive_moves():
-        return "Règle des 75 coups. Partie nulle."
-    if board.is_fivefold_repetition():
-        return "Répétition (5 fois). Partie nulle."
-    if board.is_check():
-        return "Échec !"
-    return "Partie en cours."
+        data = request.get_json()
+        fen = data.get('fen')
+        user_move = data.get('move')
+        
+        # Définir la position
+        sf.set_fen_position(fen)
+        
+        # Vérifier et jouer le coup utilisateur
+        if not sf.is_move_correct(user_move):
+            return jsonify({'error': f'Coup invalide: {user_move}'}), 400
+        
+        sf.make_moves_from_current_position([user_move])
+        
+        # Vérifier si la partie est terminée après le coup utilisateur
+        eval_after_user = sf.get_evaluation()
+        user_fen = sf.get_fen_position()
+        
+        if eval_after_user.get("type") == "mate" and eval_after_user.get("value") == 0:
+            return jsonify({
+                'fen': user_fen,
+                'stockfish_move': None,
+                'evaluation': eval_after_user,
+                'game_over': True,
+                'result': 'Mat ou Pat'
+            })
+        
+        # Obtenir le coup de Stockfish
+        stockfish_move = sf.get_best_move()
+        
+        if not stockfish_move:
+            return jsonify({
+                'fen': user_fen,
+                'stockfish_move': None,
+                'evaluation': eval_after_user,
+                'game_over': True,
+                'result': 'Partie terminée'
+            })
+        
+        # Jouer le coup de Stockfish
+        sf.make_moves_from_current_position([stockfish_move])
+        final_fen = sf.get_fen_position()
+        final_eval = sf.get_evaluation()
+        
+        # Vérifier si la partie est terminée après le coup de Stockfish
+        game_over = False
+        result = None
+        if final_eval.get("type") == "mate":
+            game_over = True
+            if final_eval.get("value") == 0:
+                result = "Mat ou Pat"
+            elif final_eval.get("value") > 0:
+                result = "Stockfish gagne"
+            else:
+                result = "Vous gagnez"
+        
+        return jsonify({
+            'fen': final_fen,
+            'stockfish_move': stockfish_move,
+            'evaluation': final_eval,
+            'game_over': game_over,
+            'result': result
+        })
+        
+    except StockfishException as e:
+        return jsonify({'error': f'Erreur Stockfish: {str(e)}'}), 500
+    except Exception as e:
+        return jsonify({'error': f'Erreur: {str(e)}'}), 500
+
+@app.route('/api/analyze', methods=['POST'])
+def analyze_position():
+    if not sf:
+        return jsonify({'error': 'Stockfish non disponible'}), 500
+    
+    try:
+        data = request.get_json()
+        fen = data.get('fen')
+        
+        sf.set_fen_position(fen)
+        evaluation = sf.get_evaluation()
+        best_move = sf.get_best_move()
+        
+        return jsonify({
+            'evaluation': evaluation,
+            'best_move': best_move
+        })
+        
+    except Exception as e:
+        return jsonify({'error': f'Erreur analyse: {str(e)}'}), 500
+
+@app.route('/api/new_game', methods=['POST'])
+def new_game():
+    starting_fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+    return jsonify({'fen': starting_fen})
 
 if __name__ == '__main__':
-    if not os.path.exists("flask_session"): # Crée le dossier pour les sessions si besoin
-        os.makedirs("flask_session")
-    app.run(debug=True)
+    app.run(debug=True, port=5000)