Update app.py

app.py

@@ -1,130 +1,190 @@
-from flask import Flask, render_template, request, jsonify
+from flask import Flask, render_template, request, jsonify, session
+import chess
+import chess.svg
 from stockfish import Stockfish, StockfishException
 import os
 
 app = Flask(__name__)
+app.secret_key = os.urandom(24) # Nécessaire pour les sessions
 
-# --- 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
-
-STOCKFISH_DEPTH = 12
-STOCKFISH_PARAMS = {
-    "Threads": 2,
-    "Hash": 128,
-    "UCI_LimitStrength": False,
-    "Skill Level": 15  # Niveau modéré (0-20)
-}
-
-# Initialiser Stockfish
-try:
-    sf = Stockfish(path=STOCKFISH_PATH, depth=STOCKFISH_DEPTH, parameters=STOCKFISH_PARAMS)
-    print(f"Stockfish initialisé: {sf._path}")
-except Exception as e:
-    print(f"Erreur Stockfish: {e}")
-    sf = None
+# Configuration du chemin vers l'exécutable de Stockfish
+# Essayez de le trouver automatiquement, sinon spécifiez le chemin
+STOCKFISH_PATH = "stockfish" # Ou le chemin complet, ex: "/usr/games/stockfish"
+if not os.path.exists(STOCKFISH_PATH):
+    # Tente quelques chemins communs si non trouvé directement
+    common_paths = ["/usr/games/stockfish", "/usr/local/bin/stockfish", "/opt/homebrew/bin/stockfish"]
+    for p in common_paths:
+        if os.path.exists(p) and os.access(p, os.X_OK):
+            STOCKFISH_PATH = p
+            break
+    else:
+        print(f"AVERTISSEMENT: Stockfish non trouvé à '{STOCKFISH_PATH}' ou dans les chemins communs. "
+              "L'IA ne fonctionnera pas. Veuillez installer Stockfish et/ou configurer STOCKFISH_PATH.")
+
+
+def get_stockfish_engine():
+    """Initialise et retourne une instance de Stockfish."""
+    try:
+        # Utilise les paramètres par défaut du wrapper, mais on peut les ajuster
+        # par ex. augmenter la Hash (RAM) et les Threads si besoin.
+        engine = Stockfish(path=STOCKFISH_PATH, depth=15, parameters={"Threads": 2, "Hash": 128})
+        # Vérifier si l'engine est bien chargé
+        if not engine._stockfish.poll() is None: # Si le process s'est terminé
+             raise StockfishException("Stockfish process terminated unexpectedly on init.")
+        engine.get_best_move() # Test rapide pour voir si ça fonctionne
+        engine.set_fen_position(chess.STARTING_FEN) # Reset
+        return engine
+    except Exception as e:
+        print(f"Erreur lors de l'initialisation de Stockfish: {e}")
+        print(f"Vérifiez que Stockfish est installé et que STOCKFISH_PATH ('{STOCKFISH_PATH}') est correct.")
+        return None
 
 @app.route('/')
 def index():
-    return render_template('index.html')
+    if 'board_fen' not in session:
+        session['board_fen'] = chess.Board().fen()
+        session['game_mode'] = 'pvp' # 'pvp' ou 'ai'
+        session['player_color'] = 'white' # Si AI, le joueur est blanc par défaut
+
+    board = chess.Board(session['board_fen'])
+    return render_template('index.html',
+                           initial_fen=session['board_fen'],
+                           board_svg=chess.svg.board(board=board, size=400),
+                           game_mode=session['game_mode'],
+                           player_color=session.get('player_color', 'white'),
+                           is_game_over=board.is_game_over(),
+                           outcome=get_outcome_message(board) if board.is_game_over() else "")
 
-@app.route('/api/move', methods=['POST'])
+def get_outcome_message(board):
+    if board.is_checkmate():
+        winner = "Blancs" if board.turn == chess.BLACK else "Noirs"
+        return f"Échec et mat ! {winner} 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."
+    return ""
+
+@app.route('/make_move', methods=['POST'])
 def make_move():
-    if not sf:
-        return jsonify({'error': 'Stockfish non disponible'}), 500
-    
+    board = chess.Board(session['board_fen'])
+    if board.is_game_over():
+        return jsonify({'error': 'La partie est terminée.', 'fen': board.fen(), 'game_over': True, 'outcome': get_outcome_message(board)})
+
+    move_uci = request.json.get('move')
+    if not move_uci:
+        return jsonify({'error': 'Mouvement non fourni.', 'fen': board.fen(), 'game_over': board.is_game_over()})
+
+    ai_move_made = None
+    ai_move_uci = None
+
     try:
-        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"
+        move = board.parse_uci(move_uci)
+    except ValueError:
+        try:
+            # Essayer de parser en SAN si l'UCI échoue (pour tests manuels par exemple)
+            move = board.parse_san(move_uci)
+        except ValueError:
+            return jsonify({'error': f'Mouvement invalide: {move_uci}', 'fen': board.fen(), 'game_over': board.is_game_over()})
+
+    if move in board.legal_moves:
+        board.push(move)
+        session['board_fen'] = board.fen()
+
+        # Si mode AI et ce n'est pas la fin du jeu pour le joueur
+        if session.get('game_mode') == 'ai' and not board.is_game_over():
+            stockfish_engine = get_stockfish_engine()
+            if stockfish_engine:
+                stockfish_engine.set_fen_position(board.fen())
+                # Augmenter le temps de réflexion pour une meilleure IA
+                # best_move_ai = stockfish_engine.get_best_move_time(1000) # 1 seconde
+                best_move_ai = stockfish_engine.get_best_move() # Utilise la profondeur configurée
+                if best_move_ai:
+                    ai_move_obj = board.parse_uci(best_move_ai)
+                    board.push(ai_move_obj)
+                    session['board_fen'] = board.fen()
+                    ai_move_made = True
+                    ai_move_uci = best_move_ai
+                else: # L'IA ne trouve pas de coup (peut arriver si mat ou pat pour l'IA)
+                    pass
+                stockfish_engine.send_quit_command() # Important pour libérer les ressources
             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
+                 return jsonify({'error': 'Moteur Stockfish non disponible.', 'fen': board.fen(), 'game_over': board.is_game_over()})
+
+    else:
+        return jsonify({'error': f'Mouvement illégal: {move_uci}', 'fen': board.fen(), 'game_over': board.is_game_over()})
+
+    game_over = board.is_game_over()
+    outcome = get_outcome_message(board) if game_over else ""
+
+    return jsonify({
+        'fen': board.fen(),
+        'board_svg': chess.svg.board(board=board, size=400, lastmove=move if not ai_move_made else ai_move_obj),
+        'game_over': game_over,
+        'outcome': outcome,
+        'ai_move_uci': ai_move_uci,
+        'turn': 'white' if board.turn == chess.WHITE else 'black'
+    })
+
+@app.route('/reset_game', methods=['POST'])
+def reset_game():
+    session['board_fen'] = chess.Board().fen()
+    # Le mode de jeu et la couleur du joueur sont conservés ou peuvent être réinitialisés ici
+    # Par exemple, pour forcer la réinitialisation du mode :
+    # session['game_mode'] = request.json.get('game_mode', 'pvp')
+    # session['player_color'] = request.json.get('player_color', 'white')
+    # ... ou simplement les effacer pour qu'ils soient redéfinis
+    if 'stockfish_engine' in session:
+        del session['stockfish_engine'] # S'assurer de le recréer
+    return jsonify({'fen': session['board_fen'],
+                    'board_svg': chess.svg.board(board=chess.Board(session['board_fen']), size=400),
+                    'game_mode': session.get('game_mode'),
+                    'player_color': session.get('player_color')})
 
-@app.route('/api/analyze', methods=['POST'])
-def analyze_position():
-    if not sf:
-        return jsonify({'error': 'Stockfish non disponible'}), 500
+
+@app.route('/set_mode', methods=['POST'])
+def set_mode_route():
+    mode = request.json.get('game_mode')
+    player_color = request.json.get('player_color', 'white') # Par défaut blanc si non spécifié
     
-    try:
-        data = request.get_json()
-        fen = data.get('fen')
-        
-        sf.set_fen_position(fen)
-        evaluation = sf.get_evaluation()
-        best_move = sf.get_best_move()
+    if mode in ['pvp', 'ai']:
+        session['game_mode'] = mode
+        session['player_color'] = player_color # 'white' or 'black' for AI mode
+        session['board_fen'] = chess.Board().fen() # Reset board on mode change
         
+        board = chess.Board()
+        initial_ai_move_uci = None
+
+        # Si l'IA joue en premier (joueur choisit noir)
+        if mode == 'ai' and player_color == 'black':
+            stockfish_engine = get_stockfish_engine()
+            if stockfish_engine:
+                stockfish_engine.set_fen_position(board.fen())
+                best_move_ai = stockfish_engine.get_best_move()
+                if best_move_ai:
+                    ai_move_obj = board.parse_uci(best_move_ai)
+                    board.push(ai_move_obj)
+                    session['board_fen'] = board.fen()
+                    initial_ai_move_uci = best_move_ai
+                stockfish_engine.send_quit_command()
+            else:
+                return jsonify({'error': 'Moteur Stockfish non disponible.'})
+
         return jsonify({
-            'evaluation': evaluation,
-            'best_move': best_move
+            'message': f'Mode de jeu réglé sur {mode}. Joueur: {player_color if mode == "ai" else "N/A"}.',
+            'fen': session['board_fen'],
+            'board_svg': chess.svg.board(board=board, size=400, lastmove=board.move_stack[-1] if initial_ai_move_uci else None),
+            'game_mode': mode,
+            'player_color': player_color,
+            'turn': 'white' if board.turn == chess.WHITE else 'black',
+            'initial_ai_move_uci': initial_ai_move_uci
         })
-        
-    except Exception as e:
-        return jsonify({'error': f'Erreur analyse: {str(e)}'}), 500
-
+    return jsonify({'error': 'Mode invalide'}), 400
 
 
 if __name__ == '__main__':
-    app.run(debug=True, port=5000)
+    app.run(debug=True)