Spaces:

Zual
/

humanchess

Sleeping

App Files Files Community

Zual commited on Oct 26, 2024

Commit

8ddaa9e

verified ·

1 Parent(s): d1a705c

Update app.py

Browse files

Files changed (1) hide show

app.py +106 -139

app.py CHANGED Viewed

@@ -1,119 +1,77 @@
 import streamlit as st
 import chess
 import os
 import git
 import sys
 import random
 # Configuration de la page
 st.set_page_config(page_title="Échecs contre IA", layout="wide")
 def render_chessboard():
-    """Render un échiquier interactif avec chessboard.js"""
-    from streamlit.components.v1 import html
-    # Conversion de la position FEN pour JavaScript
-    fen = st.session_state.board.fen()
-    last_move = ''
-    if st.session_state.board.move_stack:
-        last_move = st.session_state.board.peek().uci()
-    # Code JavaScript et HTML pour l'échiquier interactif
-    board_html = f"""
-        <html>
-        <head>
-            <link
-                rel="stylesheet"
-                href="https://cdnjs.cloudflare.com/ajax/libs/chessboard-js/1.0.0/chessboard-1.0.0.min.css"
-                integrity="sha512-TU/clvRaSqKB43MX6dvJPgxm0ytgRrg/6tkbTPCFwOXG6Ej70nGCkcFkatrbcPHqR0mlPCy3WuYNg936BGvNOg=="
-                crossorigin="anonymous"
-            />
-            <script
-                src="https://code.jquery.com/jquery-3.6.0.min.js"
-                integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4="
-                crossorigin="anonymous">
-            </script>
-            <script
-                src="https://cdnjs.cloudflare.com/ajax/libs/chessboard-js/1.0.0/chessboard-1.0.0.min.js"
-                integrity="sha512-WfASs5HtTgTL/eZs0Td0JVJZ+8tNxF/MDNU99TzJI8D4jXrZdQZRO9G7EPIVQhvmb7yUEEH+AKY9PfGi4pqrw=="
-                crossorigin="anonymous">
-            </script>
-            <script src="https://cdnjs.cloudflare.com/ajax/libs/chess.js/0.10.3/chess.min.js"></script>
-        </head>
-        <body>
-            <div id="board" style="width: 400px; margin: auto;"></div>
-            <script>
-                var board = null;
-                var game = new Chess('{fen}');
-                function onDragStart (source, piece, position, orientation) {{
-                    // Permettre seulement le déplacement des pièces blanches
-                    if (game.turn() === 'b' ||
-                        game.game_over() ||
-                        (game.turn() === 'w' && piece.search(/^b/) !== -1)) {{
-                        return false;
-                    }}
-                }}
-                function onDrop (source, target) {{
-                    var move = game.move({{
-                        from: source,
-                        to: target,
-                        promotion: 'q'
-                    }});
-                    if (move === null) return 'snapback';
-                    // Envoyer le coup au serveur via Streamlit
-                    window.parent.postMessage({{
-                        type: 'move',
-                        move: move.san
-                    }}, '*');
-                }}
-                function onSnapEnd () {{
-                    board.position(game.fen());
-                }}
-                var config = {{
-                    draggable: true,
-                    position: '{fen}',
-                    onDragStart: onDragStart,
-                    onDrop: onDrop,
-                    onSnapEnd: onSnapEnd,
-                    pieceTheme: 'https://cdnjs.cloudflare.com/ajax/libs/chessboard-js/1.0.0/img/chesspieces/wikipedia/{{piece}}.png'
-                }};
-                board = Chessboard('board', config);
-                // Marquer le dernier coup
-                if ('{last_move}') {{
-                    var sourceSquare = '{last_move}'.slice(0, 2);
-                    var targetSquare = '{last_move}'.slice(2, 4);
-                    $("div[data-square='" + sourceSquare + "']").addClass('highlight-square');
-                    $("div[data-square='" + targetSquare + "']").addClass('highlight-square');
-                }}
-            </script>
-            <style>
-                .highlight-square {{
-                    box-shadow: inset 0 0 3px 3px yellow;
-                }}
-            </style>
-        </body>
-        </html>
-    """
-    html(board_html, height=450)
 def calculate_max_length(move_count):
-    """
-    Calcule le max_length optimal basé sur le nombre de coups joués
-    """
-    base_length = 10  # Longueur minimum pour un coup simple
-    increment = 1     # Augmentation par coup
-    max_length = 100  # Plafond maximum
-    dynamic_length = base_length + (move_count * increment)
-    return min(dynamic_length, max_length)
 # Setup du modèle
 @st.cache_resource
@@ -131,30 +89,20 @@ def setup_inference():
     )
     return ChessGenerator(config)
-# Initialisation
 try:
     generator = setup_inference()
 except Exception as e:
     st.error("Erreur lors de l'initialisation.")
     st.stop()
-# Initialisation de l'état
-if 'board' not in st.session_state:
-    st.session_state.board = chess.Board()
-    st.session_state.moves = []
-    st.session_state.last_move = None
 def get_ai_move(prompt):
-    """Obtient le coup de l'IA avec max_length dynamique"""
-    print(f"\n=== Tour de l'IA ===")
     moves_count = len(st.session_state.moves)
     dynamic_max_length = calculate_max_length(moves_count)
     generator.config.max_length = dynamic_max_length
-    print(f"max_length actuel: {dynamic_max_length} pour {moves_count} coups joués")
     try:
-        if not prompt:  # Premier coup
             response = generator.generate("1.")
         else:
             moves = prompt.split()
@@ -164,12 +112,12 @@ def get_ai_move(prompt):
                 response = generator.generate(f"{last_moves} {next_move_num}")
             else:
                 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]
         try:
             move = st.session_state.board.parse_san(next_move)
             if move in st.session_state.board.legal_moves:
@@ -177,7 +125,6 @@ def get_ai_move(prompt):
         except ValueError:
             pass
-        # En cas d'échec, jouer un coup légal aléatoire
         legal_moves = list(st.session_state.board.legal_moves)
         if legal_moves:
             random_move = random.choice(legal_moves)
@@ -196,9 +143,7 @@ def try_move(move_str):
         if move in st.session_state.board.legal_moves:
             st.session_state.board.push(move)
             st.session_state.moves.append(clean_move)
-            st.session_state.last_move = clean_move
             return True
         return False
     except ValueError:
         return False
@@ -219,18 +164,21 @@ st.title("♟️ Échecs contre IA")
 col1, col2 = st.columns([2, 1])
 with col1:
-    # Échiquier interactif
     render_chessboard()
-    # Input texte comme fallback
     move = st.text_input(
-        "Ou saisissez votre coup ici",
         key=f"move_input_{len(st.session_state.moves)}",
         placeholder="ex: e4, Nf3, O-O"
     )
 with col2:
-    # Affichage du max_length actuel
     current_max_length = calculate_max_length(len(st.session_state.moves))
     st.info(f"Longueur de génération actuelle: {current_max_length} tokens")
@@ -243,7 +191,7 @@ with col2:
     # Instructions
     st.markdown("""
     **Comment jouer:**
-    - Glissez et déposez les pièces pour jouer
     - Ou utilisez la notation algébrique :
         - Pion: e4, d5
         - Cavalier: Nf3, Nc6
@@ -258,25 +206,44 @@ with col2:
     if st.button("Nouvelle partie"):
         st.session_state.board = chess.Board()
         st.session_state.moves = []
-        st.session_state.last_move = None
         st.rerun()
-# Gestion des messages JavaScript
-if st.session_state.get("js_message"):
-    move = st.session_state.js_message["move"]
-    st.session_state.js_message = None
-    if try_move(move):
-        game_str = get_game_string()
-        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()
 # Gestion des coups via input texte
 if move:

 import streamlit as st
 import chess
+import chess.svg
 import os
 import git
 import sys
 import random
+import base64
+from streamlit.components.v1 import html
 # Configuration de la page
 st.set_page_config(page_title="Échecs contre IA", layout="wide")
 def render_chessboard():
+    """Render un échiquier interactif en SVG"""
+    board_svg = chess.svg.board(
+        board=st.session_state.board,
+        size=400,
+        lastmove=st.session_state.board.peek() if st.session_state.board.move_stack else None,
+        squares=get_legal_moves_squares() if st.session_state.show_hints else None,
+    )
+    # Style pour centrer l'échiquier et ajouter des styles supplémentaires
+    html_content = f"""
+    <div style="display: flex; justify-content: center; margin-bottom: 20px;">
+        <style>
+            .chess-board {{
+                cursor: pointer;
+            }}
+            .square.legal-move {{
+                fill: #afa !important;
+                opacity: 0.5;
+            }}
+            .square.selected {{
+                fill: #0af !important;
+                opacity: 0.5;
+            }}
+            .highlight {{
+                fill: #ff0 !important;
+                opacity: 0.5;
+            }}
+        </style>
+        {board_svg}
+    </div>
+    """
+    html(html_content, height=450)
+def get_legal_moves_squares():
+    """Obtenir les cases des coups légaux pour la pièce sélectionnée"""
+    squares = []
+    if st.session_state.selected_square:
+        legal_moves = st.session_state.board.legal_moves
+        from_square = chess.parse_square(st.session_state.selected_square)
+        for move in legal_moves:
+            if move.from_square == from_square:
+                squares.append(chess.square_name(move.to_square))
+    return squares
+# Initialisation des variables de session
+if 'board' not in st.session_state:
+    st.session_state.board = chess.Board()
+if 'moves' not in st.session_state:
+    st.session_state.moves = []
+if 'selected_square' not in st.session_state:
+    st.session_state.selected_square = None
+if 'show_hints' not in st.session_state:
+    st.session_state.show_hints = True
 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
     )
     return ChessGenerator(config)
 try:
     generator = setup_inference()
 except Exception as e:
     st.error("Erreur lors de l'initialisation.")
     st.stop()
 def get_ai_move(prompt):
+    """Obtient le coup de l'IA"""
     moves_count = len(st.session_state.moves)
     dynamic_max_length = calculate_max_length(moves_count)
     generator.config.max_length = dynamic_max_length
     try:
+        if not prompt:
             response = generator.generate("1.")
         else:
             moves = prompt.split()
                 response = generator.generate(f"{last_moves} {next_move_num}")
             else:
                 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]
         try:
             move = st.session_state.board.parse_san(next_move)
             if move in st.session_state.board.legal_moves:
         except ValueError:
             pass
         legal_moves = list(st.session_state.board.legal_moves)
         if legal_moves:
             random_move = random.choice(legal_moves)
         if move in st.session_state.board.legal_moves:
             st.session_state.board.push(move)
             st.session_state.moves.append(clean_move)
             return True
         return False
     except ValueError:
         return False
 col1, col2 = st.columns([2, 1])
 with col1:
+    # Affichage de l'échiquier
     render_chessboard()
+    # Input texte comme méthode alternative
     move = st.text_input(
+        "Saisissez votre coup",
         key=f"move_input_{len(st.session_state.moves)}",
         placeholder="ex: e4, Nf3, O-O"
     )
+    # Option pour afficher les coups légaux
+    st.checkbox("Afficher les coups possibles", value=True, key="show_hints")
 with col2:
+    # Informations sur la partie
     current_max_length = calculate_max_length(len(st.session_state.moves))
     st.info(f"Longueur de génération actuelle: {current_max_length} tokens")
     # Instructions
     st.markdown("""
     **Comment jouer:**
+    - Cliquez sur une pièce puis sur la case de destination
     - Ou utilisez la notation algébrique :
         - Pion: e4, d5
         - Cavalier: Nf3, Nc6
     if st.button("Nouvelle partie"):
         st.session_state.board = chess.Board()
         st.session_state.moves = []
+        st.session_state.selected_square = None
         st.rerun()
+# Gestion des clics sur l'échiquier (à implémenter avec st.experimental_get_query_params)
+params = st.experimental_get_query_params()
+if 'square' in params:
+    clicked_square = params['square'][0]
+    if st.session_state.selected_square is None:
+        # Premier clic - sélection de la pièce
+        piece = st.session_state.board.piece_at(chess.parse_square(clicked_square))
+        if piece and piece.color == st.session_state.board.turn:
+            st.session_state.selected_square = clicked_square
+    else:
+        # Deuxième clic - déplacement
+        from_square = chess.parse_square(st.session_state.selected_square)
+        to_square = chess.parse_square(clicked_square)
+        move = chess.Move(from_square, to_square)
+        if move in st.session_state.board.legal_moves:
+            # Appliquer le coup
+            st.session_state.board.push(move)
+            st.session_state.moves.append(st.session_state.board.san(move))
+            st.session_state.selected_square = None
+            # Tour de l'IA
+            with st.spinner("L'IA réfléchit..."):
+                ai_move = get_ai_move(get_game_string())
+                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.session_state.selected_square = None
+    st.rerun()
 # Gestion des coups via input texte
 if move: