Update app.py

app.py

@@ -1,208 +1,198 @@
-# app.py
 from flask import Flask, render_template, request, jsonify, session
 from stockfish import Stockfish
 import uuid
-import chess
-import chess.pgn
-from datetime import datetime
+import json
 
 app = Flask(__name__)
 app.secret_key = 'your-secret-key-change-this'
 
 # Configuration Stockfish
-try:
-    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é.")
+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'):
+    def __init__(self, game_id, mode="human"):
         self.game_id = game_id
-        self.mode = mode  # 'human' ou 'ai'
-        self.board = chess.Board()
+        self.mode = mode  # "human" ou "ai"
+        self.current_player = "white"
         self.moves_history = []
-        self.current_player = 'white'
-        self.game_status = 'active'  # 'active', 'checkmate', 'stalemate', 'draw'
-        self.created_at = datetime.now()
+        self.game_over = False
+        self.winner = None
         
-    def make_move(self, move_uci):
-        """Effectue un coup et retourne le résultat"""
-        try:
-            move = chess.Move.from_uci(move_uci)
+        # 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
             
-            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)}
+        # 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 get_ai_move(self):
-        """Obtient le coup de l'IA via Stockfish"""
-        if not stockfish or self.mode != 'ai':
-            return None
+    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()
             
-        try:
-            stockfish.set_fen_position(self.board.fen())
-            ai_move = stockfish.get_best_move()
-            return ai_move
-        except:
+            # 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 _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"""
+    def get_game_state(self):
+        """Obtenir l'état complet du jeu"""
         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)
+            "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()
         }
 
-# 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('/game/<mode>')
-def game(mode):
-    if mode not in ['human', 'ai']:
-        return "Mode de jeu invalide", 400
+@app.route('/api/new_game', methods=['POST'])
+def new_game():
+    """Créer une nouvelle partie"""
+    data = request.json
+    mode = data.get('mode', 'human')  # 'human' ou 'ai'
     
-    # Créer une nouvelle partie
     game_id = str(uuid.uuid4())
-    games[game_id] = ChessGame(game_id, mode)
+    game = ChessGame(game_id, mode)
+    games[game_id] = game
+    
+    # Stocker l'ID de partie dans la session
     session['game_id'] = game_id
     
-    return render_template('game.html', mode=mode, game_id=game_id)
+    return jsonify({
+        "success": True,
+        "game_state": game.get_game_state()
+    })
 
-@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'])
+@app.route('/api/make_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
-    
+    """Effectuer un coup"""
     data = request.json
+    game_id = session.get('game_id')
     move = data.get('move')
     
-    if not move:
-        return jsonify({'error': 'Coup manquant'}), 400
-    
-    game = games[game_id]
-    result = game.make_move(move)
-    
-    return jsonify(result)
-
-@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
+        return jsonify({"success": False, "error": "Partie non trouvée"})
     
     game = games[game_id]
+    success, message = game.make_move(move)
     
-    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
+    if not success:
+        return jsonify({"success": False, "error": message})
     
-    ai_move = game.get_ai_move()
-    if not ai_move:
-        return jsonify({'error': 'IA ne peut pas jouer'}), 500
+    response_data = {
+        "success": True,
+        "game_state": game.get_game_state()
+    }
     
-    # Effectuer le coup de l'IA
-    result = game.make_move(ai_move)
-    result['ai_move'] = True
+    # 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(result)
+    return jsonify(response_data)
 
-@app.route('/api/game/reset', methods=['POST'])
-def reset_game():
+@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({'error': 'Partie non trouvée'}), 404
+        return jsonify({"success": False, "error": "Partie non trouvée"})
     
     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({
+        "success": True,
+        "game_state": game.get_game_state()
+    })
 
-@app.route('/api/game/legal-moves')
+@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({'error': 'Partie non trouvée'}), 404
-    
-    data = request.args
-    square = data.get('square')
     
-    if not square:
-        return jsonify({'error': 'Case manquante'}), 400
+    if not game_id or game_id not in games:
+        return jsonify({"success": False, "error": "Partie non trouvée"})
     
     game = games[game_id]
-    legal_moves = []
+    return jsonify({
+        "success": True,
+        "legal_moves": game.get_legal_moves()
+    })
+
+@app.route('/api/reset_game', methods=['POST'])
+def reset_game():
+    """Réinitialiser la partie actuelle"""
+    game_id = session.get('game_id')
     
-    for move in game.board.legal_moves:
-        if move.from_square == chess.parse_square(square):
-            legal_moves.append(chess.square_name(move.to_square))
+    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({'legal_moves': legal_moves})
+    return jsonify({"success": False, "error": "Partie non trouvée"})
 
 if __name__ == '__main__':
     app.run(debug=True)