Update app.py

app.py

@@ -5,33 +5,144 @@ import os
 import git
 import sys
 import random
+from streamlit.components.v1 import html
 
 # Configuration de la page
 st.set_page_config(page_title="Échecs contre IA", layout="wide")
 
 def render_board():
-    """Rendre l'échiquier en SVG avec mise en évidence des coups légaux"""
-    # Déterminer les cases à mettre en évidence
-    squares = None
-    last_move = None
-    
-    if st.session_state.board.move_stack:
-        last_move = st.session_state.board.peek()
-    
-    # Créer le SVG
+    """Rendre l'échiquier interactif"""
+    # Générer le SVG de l'échiquier
     board_svg = chess.svg.board(
         board=st.session_state.board,
         size=400,
-        lastmove=last_move,
-        check=st.session_state.board.king(st.session_state.board.turn) if st.session_state.board.is_check() else None
+        lastmove=st.session_state.board.peek() if st.session_state.board.move_stack else None,
     )
     
-    # On utilise unsafe_allow_html=True car on sait que le SVG est sûr (généré par python-chess)
-    st.write(board_svg, unsafe_allow_html=True)
+    # Code HTML/JS pour rendre l'échiquier interactif
+    html_content = f"""
+        <style>
+            #chess-board {{
+                user-select: none;
+                position: relative;
+                width: 400px;
+                margin: auto;
+            }}
+            .dragging {{
+                opacity: 0.8;
+                cursor: grabbing !important;
+            }}
+            .piece {{
+                cursor: grab;
+            }}
+            .square {{
+                cursor: pointer;
+            }}
+            .highlight {{
+                fill: yellow;
+                opacity: 0.5;
+            }}
+            .last-move {{
+                fill: #aaf;
+                opacity: 0.5;
+            }}
+        </style>
+        
+        <div id="chess-board">
+            {board_svg}
+        </div>
+
+        <script>
+            (function() {{
+                const board = document.querySelector('#chess-board');
+                let draggedPiece = null;
+                let startSquare = null;
+                let isDragging = false;
+                let dragStartX = 0;
+                let dragStartY = 0;
+                let originalTransform = null;
+                
+                // Convertir les coordonnées en notation algébrique
+                function getSquareFromCoords(x, y) {{
+                    const boardRect = board.getBoundingClientRect();
+                    const squareSize = boardRect.width / 8;
+                    const file = Math.floor((x - boardRect.left) / squareSize);
+                    const rank = 7 - Math.floor((y - boardRect.top) / squareSize);
+                    if (file >= 0 && file < 8 && rank >= 0 && rank < 8) {{
+                        return String.fromCharCode(97 + file) + (rank + 1);
+                    }}
+                    return null;
+                }}
+
+                // Déplacer la pièce
+                function movePiece(piece, x, y) {{
+                    const deltaX = x - dragStartX;
+                    const deltaY = y - dragStartY;
+                    piece.style.transform = `translate(${{deltaX}}px, ${{deltaY}}px)`;
+                }}
+
+                // Début du glissement
+                board.addEventListener('mousedown', function(e) {{
+                    const piece = e.target.closest('.piece');
+                    if (piece && piece.classList.contains('white')) {{
+                        isDragging = true;
+                        draggedPiece = piece;
+                        dragStartX = e.clientX;
+                        dragStartY = e.clientY;
+                        startSquare = getSquareFromCoords(e.clientX, e.clientY);
+                        originalTransform = window.getComputedStyle(piece).transform;
+                        
+                        piece.classList.add('dragging');
+                        e.preventDefault();
+                    }}
+                }});
+
+                // Glissement
+                document.addEventListener('mousemove', function(e) {{
+                    if (isDragging && draggedPiece) {{
+                        movePiece(draggedPiece, e.clientX, e.clientY);
+                    }}
+                }});
+
+                // Fin du glissement
+                document.addEventListener('mouseup', function(e) {{
+                    if (isDragging && draggedPiece) {{
+                        const endSquare = getSquareFromCoords(e.clientX, e.clientY);
+                        
+                        // Réinitialiser la position de la pièce
+                        draggedPiece.style.transform = originalTransform;
+                        draggedPiece.classList.remove('dragging');
+                        
+                        // Envoyer le coup si valide
+                        if (startSquare && endSquare && startSquare !== endSquare) {{
+                            window.parent.postMessage({{
+                                type: 'chess_move',
+                                from: startSquare,
+                                to: endSquare
+                            }}, '*');
+                        }}
+                        
+                        isDragging = false;
+                        draggedPiece = null;
+                        startSquare = null;
+                    }}
+                }});
+            }})();
+        </script>
+    """
+    
+    html(html_content, height=450)
+
+def calculate_max_length(move_count):
+    """Calcule le max_length optimal"""
+    base_length = 10
+    increment = 1
+    max_length = 100
+    return min(base_length + (move_count * increment), max_length)
 
-# Setup du modèle
 @st.cache_resource
 def setup_inference():
+    """Initialise le modèle d'IA"""
     if not os.path.exists('chess'):
         git.Repo.clone_from('https://github.com/l-pommeret/chess.git', 'chess')
     if 'chess' not in sys.path:
@@ -45,25 +156,12 @@ def setup_inference():
     )
     return ChessGenerator(config)
 
-# Initialisation
-try:
-    generator = setup_inference()
-except Exception as e:
-    st.error(f"Erreur lors de l'initialisation: {str(e)}")
-    st.stop()
-
-# Initialisation de l'état
-if 'board' not in st.session_state:
-    st.session_state.board = chess.Board()
-if 'moves' not in st.session_state:
-    st.session_state.moves = []
-
-def calculate_max_length(move_count):
-    """Calcule le max_length optimal"""
-    base_length = 10
-    increment = 1
-    max_length = 100
-    return min(base_length + (move_count * increment), max_length)
+def initialize_state():
+    """Initialise ou réinitialise l'état du jeu"""
+    if 'board' not in st.session_state:
+        st.session_state.board = chess.Board()
+    if 'moves' not in st.session_state:
+        st.session_state.moves = []
 
 def get_ai_move(prompt):
     """Obtient le coup de l'IA"""
@@ -76,18 +174,20 @@ def get_ai_move(prompt):
             response = generator.generate("1.")
         else:
             moves = prompt.split()
-            last_moves = " ".join(moves[-4:])
-            if len(moves) % 2 == 0:
+            last_moves = " ".join(moves[-4:])  # Garder seulement les 2 derniers coups
+            
+            if len(moves) % 2 == 0:  # Tour des blancs
                 next_move_num = f"{(len(moves)//2 + 1)}."
                 response = generator.generate(f"{last_moves} {next_move_num}")
-            else:
+            else:  # Tour des noirs
                 response = generator.generate(f"{last_moves}")
         
         moves = response[0].split() if isinstance(response, list) else response.split()
         next_move = moves[-1]
         if '.' in next_move and len(moves) > 1:
             next_move = moves[-2]
-        
+            
+        # Vérifier si le coup est légal
         try:
             move = st.session_state.board.parse_san(next_move)
             if move in st.session_state.board.legal_moves:
@@ -95,17 +195,18 @@ def get_ai_move(prompt):
         except ValueError:
             pass
         
-        # En cas d'échec, jouer un coup légal aléatoire
+        # Si le coup n'est pas légal, jouer un coup aléatoire
         legal_moves = list(st.session_state.board.legal_moves)
         if legal_moves:
             random_move = random.choice(legal_moves)
             return st.session_state.board.san(random_move)
+            
     except Exception as e:
-        st.error(f"Erreur lors de la génération du coup de l'IA: {str(e)}")
+        st.error(f"Erreur lors de la génération du coup: {str(e)}")
         return None
 
 def try_move(move_str):
-    """Applique un coup au plateau"""
+    """Tente d'appliquer un coup"""
     try:
         clean_move = move_str.split('.')[-1].strip()
         move = st.session_state.board.parse_san(clean_move)
@@ -119,7 +220,7 @@ def try_move(move_str):
         return False
 
 def get_game_string():
-    """Renvoie la notation de la partie"""
+    """Obtient la notation de la partie"""
     result = []
     for i in range(0, len(st.session_state.moves), 2):
         move_num = i//2 + 1
@@ -128,11 +229,23 @@ def get_game_string():
             result.append(st.session_state.moves[i+1])
     return " ".join(result)
 
-def display_legal_moves():
-    """Affiche les coups légaux possibles"""
-    legal_moves = [st.session_state.board.san(move) for move in st.session_state.board.legal_moves]
-    st.text("Coups légaux possibles:")
-    st.code(", ".join(legal_moves))
+def handle_move(move_from, move_to):
+    """Gère un coup joué via l'interface graphique"""
+    move = chess.Move.from_uci(f"{move_from}{move_to}")
+    if move in st.session_state.board.legal_moves:
+        san_move = st.session_state.board.san(move)
+        if try_move(san_move):
+            return True
+    return False
+
+# Initialisation
+try:
+    generator = setup_inference()
+except Exception as e:
+    st.error(f"Erreur d'initialisation: {str(e)}")
+    st.stop()
+
+initialize_state()
 
 # Interface utilisateur
 st.title("♟️ Échecs contre IA")
@@ -140,22 +253,18 @@ st.title("♟️ Échecs contre IA")
 col1, col2 = st.columns([2, 1])
 
 with col1:
-    # Échiquier
+    # Échiquier interactif
     render_board()
     
-    # Input du coup
+    # Input texte alternatif
     move = st.text_input(
-        "Votre coup",
+        "Ou saisissez votre coup ici",
         key=f"move_input_{len(st.session_state.moves)}",
         placeholder="ex: e4, Nf3, O-O"
     )
-    
-    # Afficher les coups légaux si demandé
-    if st.checkbox("Afficher les coups possibles"):
-        display_legal_moves()
 
 with col2:
-    # Historique et état de la partie
+    # Informations de la partie
     st.subheader("Partie en cours")
     game_str = get_game_string()
     if game_str:
@@ -164,13 +273,15 @@ with col2:
     # Instructions
     st.markdown("""
     **Comment jouer:**
-    - Pion: e4, d5
-    - Cavalier: Nf3, Nc6
-    - Fou: Bc4, Be7
-    - Tour: Ra1, Rd8
-    - Dame: Qd1, Qh4
-    - Roi: Ke2, Kg8
-    - Roque: O-O ou O-O-O
+    - Glissez et déposez les pièces blanches
+    - Ou utilisez la notation algébrique :
+        - Pion: e4, d5
+        - Cavalier: Nf3, Nc6
+        - Fou: Bc4, Be7
+        - Tour: Ra1, Rd8
+        - Dame: Qd1, Qh4
+        - Roi: Ke2, Kg8
+        - Roque: O-O ou O-O-O
     """)
     
     # Nouvelle partie
@@ -179,7 +290,27 @@ with col2:
         st.session_state.moves = []
         st.rerun()
 
-# Logique du jeu
+# Gestion des coups (glisser-déposer et texte)
+if st.session_state.get("chess_move"):
+    move_data = st.session_state.chess_move
+    st.session_state.chess_move = None
+    if handle_move(move_data["from"], move_data["to"]):
+        game_str = get_game_string()
+        # Tour de l'IA
+        with st.spinner("L'IA réfléchit..."):
+            ai_move = get_ai_move(game_str)
+            if ai_move and try_move(ai_move):
+                if st.session_state.board.is_checkmate():
+                    st.success("Échec et mat!")
+                elif st.session_state.board.is_game_over():
+                    st.info("Partie terminée!")
+            else:
+                st.error("Problème avec le coup de l'IA")
+        st.rerun()
+    else:
+        st.error("Coup invalide")
+
+# Gestion des coups via input texte
 if move:
     if try_move(move):
         game_str = get_game_string()