Update app.py

app.py

@@ -1,127 +1,208 @@
+# app.py
 from flask import Flask, render_template, request, jsonify, session
-from stockfish import Stockfish # Assurez-vous que le chemin est correct si besoin
-import chess # python-chess
+from stockfish import Stockfish
+import uuid
+import chess
+import chess.pgn
+from datetime import datetime
 
 app = Flask(__name__)
-app.secret_key = 'super_secret_key_for_session' # Important pour les sessions
+app.secret_key = 'your-secret-key-change-this'
 
-# Pour simplifier, une instance globale. Pour une prod, gérer par session/jeu.
-# Assurez-vous que le binaire stockfish est dans votre PATH ou spécifiez le chemin.
+# Configuration Stockfish
 try:
-    stockfish_path = "/usr/games/stockfish" # chemin vers votre binaire
-    stockfish = Stockfish(path=stockfish_path, parameters={"Threads": 2, "Hash": 128})
-except Exception as e:
-    print(f"Erreur à l'initialisation de Stockfish: {e}")
-    print("Veuillez vérifier que Stockfish est installé et accessible via le PATH, ou spécifiez le chemin correct.")
-    # Vous pourriez vouloir quitter l'application ou avoir un mode dégradé.
+    stockfish = Stockfish(
+        path="/usr/local/bin/stockfish",  # Ajustez selon votre installation
+        parameters={
+            "Threads": 2,
+            "Hash": 256,
+            "Skill Level": 15,  # Niveau IA (0-20)
+            "Minimum Thinking Time": 100
+        }
+    )
+except:
     stockfish = None
-
+    print("Stockfish non trouvé. Mode IA désactivé.")
+
+class ChessGame:
+    def __init__(self, game_id, mode='human'):
+        self.game_id = game_id
+        self.mode = mode  # 'human' ou 'ai'
+        self.board = chess.Board()
+        self.moves_history = []
+        self.current_player = 'white'
+        self.game_status = 'active'  # 'active', 'checkmate', 'stalemate', 'draw'
+        self.created_at = datetime.now()
+        
+    def make_move(self, move_uci):
+        """Effectue un coup et retourne le résultat"""
+        try:
+            move = chess.Move.from_uci(move_uci)
+            
+            if move in self.board.legal_moves:
+                self.board.push(move)
+                self.moves_history.append(move_uci)
+                
+                # Changer de joueur
+                self.current_player = 'black' if self.current_player == 'white' else 'white'
+                
+                # Vérifier l'état du jeu
+                self._update_game_status()
+                
+                return {
+                    'success': True,
+                    'move': move_uci,
+                    'board_fen': self.board.fen(),
+                    'current_player': self.current_player,
+                    'game_status': self.game_status,
+                    'legal_moves': [move.uci() for move in self.board.legal_moves],
+                    'is_check': self.board.is_check()
+                }
+            else:
+                return {'success': False, 'error': 'Coup illégal'}
+                
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+    
+    def get_ai_move(self):
+        """Obtient le coup de l'IA via Stockfish"""
+        if not stockfish or self.mode != 'ai':
+            return None
+            
+        try:
+            stockfish.set_fen_position(self.board.fen())
+            ai_move = stockfish.get_best_move()
+            return ai_move
+        except:
+            return None
+    
+    def _update_game_status(self):
+        """Met à jour l'état du jeu"""
+        if self.board.is_checkmate():
+            winner = 'black' if self.current_player == 'white' else 'white'
+            self.game_status = f'checkmate_{winner}'
+        elif self.board.is_stalemate():
+            self.game_status = 'stalemate'
+        elif self.board.is_insufficient_material():
+            self.game_status = 'draw_material'
+        elif self.board.is_seventyfive_moves():
+            self.game_status = 'draw_75moves'
+        elif self.board.is_fivefold_repetition():
+            self.game_status = 'draw_repetition'
+    
+    def get_board_state(self):
+        """Retourne l'état complet du plateau"""
+        return {
+            'fen': self.board.fen(),
+            'current_player': self.current_player,
+            'game_status': self.game_status,
+            'legal_moves': [move.uci() for move in self.board.legal_moves],
+            'is_check': self.board.is_check(),
+            'moves_history': self.moves_history,
+            'move_count': len(self.moves_history)
+        }
+
+# Stockage des parties en mémoire (remplacez par une base de données en production)
+games = {}
 
 @app.route('/')
 def index():
     return render_template('index.html')
 
-@app.route('/new_game', methods=['POST'])
-def new_game():
-    if not stockfish:
-        return jsonify({"error": "Stockfish non initialisé"}), 500
-        
-    data = request.json
-    mode = data.get('mode', 'human') # 'ai' or 'human'
+@app.route('/game/<mode>')
+def game(mode):
+    if mode not in ['human', 'ai']:
+        return "Mode de jeu invalide", 400
     
-    initial_fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
-    session['fen'] = initial_fen
-    session['mode'] = mode
-    session['turn'] = 'w' # White's turn
-    session['history'] = []
+    # Créer une nouvelle partie
+    game_id = str(uuid.uuid4())
+    games[game_id] = ChessGame(game_id, mode)
+    session['game_id'] = game_id
     
-    stockfish.set_fen_position(initial_fen)
-    
-    # python-chess board (optionnel mais recommandé)
-    session['board_pgn'] = chess.Board().fen() # Stocker le FEN pour reconstruire
-
-    return jsonify({
-        "fen": initial_fen,
-        "turn": session['turn'],
-        "message": "Nouvelle partie commencée."
-    })
-
-@app.route('/move', methods=['POST'])
-def handle_move():
-    if not stockfish:
-        return jsonify({"error": "Stockfish non initialisé"}), 500
-
-    if 'fen' not in session:
-        return jsonify({"error": "Aucune partie en cours. Commencez une nouvelle partie."}), 400
+    return render_template('game.html', mode=mode, game_id=game_id)
 
+@app.route('/api/game/state')
+def get_game_state():
+    game_id = session.get('game_id')
+    if not game_id or game_id not in games:
+        return jsonify({'error': 'Partie non trouvée'}), 404
+    
+    game = games[game_id]
+    return jsonify(game.get_board_state())
+
+@app.route('/api/game/move', methods=['POST'])
+def make_move():
+    game_id = session.get('game_id')
+    if not game_id or game_id not in games:
+        return jsonify({'error': 'Partie non trouvée'}), 404
+    
     data = request.json
-    move_uci = data.get('move') # e.g., "e2e4"
-
-    # Reconstruire l'état du board python-chess (si utilisé)
-    board = chess.Board(session['fen'])
+    move = data.get('move')
     
-    # Validation du tour
-    current_player_color = 'w' if board.turn == chess.WHITE else 'b'
-    if session['turn'] != current_player_color:
-         return jsonify({"error": "Pas votre tour.", "fen": session['fen'], "turn": session['turn']}), 400
-
-    try:
-        move_obj = board.parse_uci(move_uci)
-    except ValueError:
-        return jsonify({"error": "Format de coup invalide.", "fen": session['fen'], "turn": session['turn']}), 400
-
-
-    if not stockfish.is_move_correct(move_uci) or move_obj not in board.legal_moves:
-        return jsonify({"error": "Coup illégal.", "fen": session['fen'], "turn": session['turn']}), 400
-
-    # Appliquer le coup humain
-    stockfish.make_moves_from_current_position([move_uci])
-    board.push(move_obj)
-    session['fen'] = stockfish.get_fen_position() # ou board.fen()
-    session['history'].append(move_uci)
-    session['turn'] = 'b' if current_player_color == 'w' else 'w'
-    
-    ai_move_uci = None
-    game_status = "En cours"
-
-    if board.is_checkmate():
-        game_status = f"Mat! {'Les Blancs' if board.turn == chess.BLACK else 'Les Noirs'} gagnent."
-    elif board.is_stalemate() or board.is_insufficient_material() or board.is_seventyfive_moves() or board.is_fivefold_repetition():
-        game_status = "Pat!"
-        
-    # Mode IA
-    if session['mode'] == 'ai' and game_status == "En cours" and ( (board.turn == chess.BLACK and current_player_color == 'w') or \
-                                                                    (board.turn == chess.WHITE and current_player_color == 'b') ) : # Tour de l'IA
-        # S'assurer que stockfish a la bonne position si on utilise board.fen()
-        stockfish.set_fen_position(board.fen()) 
-        ai_move_uci = stockfish.get_best_move_time(1000) # 1 seconde de réflexion
-        if ai_move_uci:
-            ai_move_obj = board.parse_uci(ai_move_uci)
-            stockfish.make_moves_from_current_position([ai_move_uci]) # Stockfish est déjà à jour
-            board.push(ai_move_obj)
-            session['fen'] = stockfish.get_fen_position() # ou board.fen()
-            session['history'].append(ai_move_uci)
-            session['turn'] = 'w' if session['turn'] == 'b' else 'b'
+    if not move:
+        return jsonify({'error': 'Coup manquant'}), 400
+    
+    game = games[game_id]
+    result = game.make_move(move)
+    
+    return jsonify(result)
 
-            if board.is_checkmate():
-                 game_status = f"Mat! {'Les Blancs' if board.turn == chess.BLACK else 'Les Noirs'} gagnent."
-            elif board.is_stalemate() or board.is_insufficient_material() or board.is_seventyfive_moves() or board.is_fivefold_repetition():
-                game_status = "Pat!"
-        else: # Si l'IA ne retourne pas de coup (ce qui peut arriver si elle est matée/patée)
-            if board.is_checkmate():
-                 game_status = f"Mat! {'Les Blancs' if board.turn == chess.BLACK else 'Les Noirs'} gagnent."
-            elif board.is_stalemate():
-                game_status = "Pat!"
+@app.route('/api/game/ai-move', methods=['POST'])
+def get_ai_move():
+    game_id = session.get('game_id')
+    if not game_id or game_id not in games:
+        return jsonify({'error': 'Partie non trouvée'}), 404
+    
+    game = games[game_id]
+    
+    if game.mode != 'ai':
+        return jsonify({'error': 'Mode IA non activé'}), 400
+    
+    if game.current_player != 'black':  # IA joue les noirs
+        return jsonify({'error': 'Ce n\'est pas le tour de l\'IA'}), 400
+    
+    ai_move = game.get_ai_move()
+    if not ai_move:
+        return jsonify({'error': 'IA ne peut pas jouer'}), 500
+    
+    # Effectuer le coup de l'IA
+    result = game.make_move(ai_move)
+    result['ai_move'] = True
+    
+    return jsonify(result)
 
+@app.route('/api/game/reset', methods=['POST'])
+def reset_game():
+    game_id = session.get('game_id')
+    if not game_id or game_id not in games:
+        return jsonify({'error': 'Partie non trouvée'}), 404
+    
+    game = games[game_id]
+    # Réinitialiser la partie
+    games[game_id] = ChessGame(game_id, game.mode)
+    
+    return jsonify({'success': True, 'message': 'Partie réinitialisée'})
 
-    return jsonify({
-        "fen": session['fen'],
-        "turn": session['turn'],
-        "last_move_human": move_uci,
-        "last_move_ai": ai_move_uci,
-        "game_status": game_status,
-        "history": session['history']
-    })
+@app.route('/api/game/legal-moves')
+def get_legal_moves():
+    game_id = session.get('game_id')
+    if not game_id or game_id not in games:
+        return jsonify({'error': 'Partie non trouvée'}), 404
+    
+    data = request.args
+    square = data.get('square')
+    
+    if not square:
+        return jsonify({'error': 'Case manquante'}), 400
+    
+    game = games[game_id]
+    legal_moves = []
+    
+    for move in game.board.legal_moves:
+        if move.from_square == chess.parse_square(square):
+            legal_moves.append(chess.square_name(move.to_square))
+    
+    return jsonify({'legal_moves': legal_moves})
 
 if __name__ == '__main__':
     app.run(debug=True)