Update app.py

app.py

@@ -1,198 +1,181 @@
 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
-import uuid
-import json
+import os
 
 app = Flask(__name__)
-app.secret_key = 'your-secret-key-change-this'
-
-# Configuration Stockfish
-STOCKFISH_PATH = "/usr/games/stockfish"  # Ajustez selon votre installation
-
-# Stockage des parties en cours (en production, utilisez une base de données)
-games = {}
-
-class ChessGame:
-    def __init__(self, game_id, mode="human"):
-        self.game_id = game_id
-        self.mode = mode  # "human" ou "ai"
-        self.current_player = "white"
-        self.moves_history = []
-        self.game_over = False
-        self.winner = None
-        
-        # Initialiser Stockfish pour le mode AI
-        if mode == "ai":
-            try:
-                self.stockfish = Stockfish(path=STOCKFISH_PATH)
-                self.stockfish.set_depth(10)
-            except:
-                # Fallback si Stockfish n'est pas trouvé
-                self.stockfish = None
-                print("Attention: Stockfish non trouvé, mode AI désactivé")
-        else:
-            self.stockfish = None
-            
-        # Position de départ FEN
-        self.fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
-        
-        if self.stockfish:
-            self.stockfish.set_fen_position(self.fen)
-    
-    def make_move(self, move):
-        """Effectuer un coup"""
-        if self.game_over:
-            return False, "La partie est terminée"
-        
-        if self.stockfish:
-            # Vérifier si le coup est légal
-            legal_moves = self.stockfish.get_legal_moves()
-            if move not in legal_moves:
-                return False, "Coup illégal"
-            
-            # Effectuer le coup
-            self.stockfish.make_moves_from_current_position([move])
-            self.fen = self.stockfish.get_fen_position()
-            
-            # Vérifier fin de partie
-            if self.stockfish.is_game_over():
-                self.game_over = True
-                if self.stockfish.is_checkmate():
-                    self.winner = self.current_player
-                else:
-                    self.winner = "draw"
-        else:
-            # Mode basique sans validation (pour le mode humain sans Stockfish)
-            pass
-        
-        self.moves_history.append(move)
-        self.current_player = "black" if self.current_player == "white" else "white"
-        
-        return True, "Coup effectué"
-    
-    def get_ai_move(self):
-        """Obtenir le coup de l'IA"""
-        if not self.stockfish or self.current_player != "black":
-            return None
-        
-        best_move = self.stockfish.get_best_move()
-        return best_move
-    
-    def get_legal_moves(self):
-        """Obtenir les coups légaux"""
-        if self.stockfish:
-            return self.stockfish.get_legal_moves()
-        return []
-    
-    def get_game_state(self):
-        """Obtenir l'état complet du jeu"""
-        return {
-            "game_id": self.game_id,
-            "mode": self.mode,
-            "current_player": self.current_player,
-            "fen": self.fen,
-            "moves_history": self.moves_history,
-            "game_over": self.game_over,
-            "winner": self.winner,
-            "legal_moves": self.get_legal_moves()
-        }
+
+# 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 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 !
+
+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()}")
+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é)
 
 @app.route('/')
 def index():
-    return render_template('index.html')
+    """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('/api/new_game', methods=['POST'])
+@app.route('/new_game', methods=['POST'])
 def new_game():
-    """Créer une nouvelle partie"""
-    data = request.json
-    mode = data.get('mode', 'human')  # 'human' ou 'ai'
-    
-    game_id = str(uuid.uuid4())
-    game = ChessGame(game_id, mode)
-    games[game_id] = game
-    
-    # Stocker l'ID de partie dans la session
-    session['game_id'] = game_id
-    
+    """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
+
+    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({
-        "success": True,
-        "game_state": game.get_game_state()
+        '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('/api/make_move', methods=['POST'])
+@app.route('/move', methods=['POST'])
 def make_move():
-    """Effectuer un coup"""
-    data = request.json
-    game_id = session.get('game_id')
-    move = data.get('move')
-    
-    if not game_id or game_id not in games:
-        return jsonify({"success": False, "error": "Partie non trouvée"})
-    
-    game = games[game_id]
-    success, message = game.make_move(move)
-    
-    if not success:
-        return jsonify({"success": False, "error": message})
-    
-    response_data = {
-        "success": True,
-        "game_state": game.get_game_state()
-    }
-    
-    # Si c'est le mode AI et c'est au tour de l'IA
-    if game.mode == "ai" and game.current_player == "black" and not game.game_over:
-        ai_move = game.get_ai_move()
-        if ai_move:
-            game.make_move(ai_move)
-            response_data["ai_move"] = ai_move
-            response_data["game_state"] = game.get_game_state()
-    
-    return jsonify(response_data)
-
-@app.route('/api/game_state', methods=['GET'])
-def get_game_state():
-    """Obtenir l'état actuel du jeu"""
-    game_id = session.get('game_id')
-    
-    if not game_id or game_id not in games:
-        return jsonify({"success": False, "error": "Partie non trouvée"})
-    
-    game = games[game_id]
+    """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
+    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({
-        "success": True,
-        "game_state": game.get_game_state()
+        '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('/api/legal_moves', methods=['GET'])
-def get_legal_moves():
-    """Obtenir les coups légaux pour la position actuelle"""
-    game_id = session.get('game_id')
-    
-    if not game_id or game_id not in games:
-        return jsonify({"success": False, "error": "Partie non trouvée"})
-    
-    game = games[game_id]
+@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({
-        "success": True,
-        "legal_moves": game.get_legal_moves()
+        '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)
     })
 
-@app.route('/api/reset_game', methods=['POST'])
-def reset_game():
-    """Réinitialiser la partie actuelle"""
-    game_id = session.get('game_id')
-    
-    if game_id and game_id in games:
-        mode = games[game_id].mode
-        games[game_id] = ChessGame(game_id, mode)
-        
-        return jsonify({
-            "success": True,
-            "game_state": games[game_id].get_game_state()
-        })
-    
-    return jsonify({"success": False, "error": "Partie non trouvée"})
+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."
 
 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)