Fixed drop down options for human

app.py

@@ -597,6 +597,8 @@ with gr.Blocks() as interface:
 
         # Create gr.State for interactive games
         game_state = gr.State(value=None)
+        human_choices_p0 = gr.State([])
+        human_choices_p1 = gr.State([])
 
         # Interactive game components (initially hidden)
         with gr.Column(visible=False) as interactive_panel:
@@ -616,22 +618,22 @@ with gr.Blocks() as interface:
                     gr.Markdown("### Your Move")
 
                     # Player 0 move selection
-                    p0_move_dropdown = gr.Dropdown(
+                    human_move_p0 = gr.Dropdown(
                         choices=[],
-                        label="Player 0 Action",
+                        label="Your move (Player 0)",
                         visible=False,
                         interactive=True,
                     )
 
                     # Player 1 move selection
-                    p1_move_dropdown = gr.Dropdown(
+                    human_move_p1 = gr.Dropdown(
                         choices=[],
-                        label="Player 1 Action",
+                        label="Your move (Player 1)",
                         visible=False,
                         interactive=True,
                     )
 
-                    submit_move_btn = gr.Button(
+                    submit_btn = gr.Button(
                         "Submit Move",
                         variant="primary",
                         visible=False
@@ -644,7 +646,7 @@ with gr.Blocks() as interface:
 
         # Standard game simulation (non-interactive)
         play_button = gr.Button("🎮 Start Game", variant="primary")
-        start_interactive_btn = gr.Button("🎯 Start Interactive Game", variant="secondary", visible=False)
+        start_btn = gr.Button("🎯 Start Interactive Game", variant="secondary", visible=False)
 
         game_output = gr.Textbox(
             label="Game Log",
@@ -662,7 +664,7 @@ with gr.Blocks() as interface:
             has_human = (p1_key == "human" or p2_key == "human")
             return (
                 gr.update(visible=has_human),  # interactive_panel
-                gr.update(visible=has_human),  # start_interactive_btn
+                gr.update(visible=has_human),  # start_btn
                 gr.update(visible=not has_human),  # play_button (single-shot)
             )
 
@@ -671,7 +673,7 @@ with gr.Blocks() as interface:
             player_type_dropdown.change(
                 check_for_human_players,
                 inputs=[p1_type, p2_type],
-                outputs=[interactive_panel, start_interactive_btn, play_button],
+                outputs=[interactive_panel, start_btn, play_button],
             )
 
         # Standard single-shot game
@@ -716,87 +718,121 @@ with gr.Blocks() as interface:
                     player2_model=p2_model,
                     rounds=rounds,
                     seed=seed,
-                )                # Update dropdowns with legal actions
-                p0_choices = [(action, label) for action, label in legal_p0]
-                p1_choices = [(action, label) for action, label in legal_p1]
+                )
+
+                # Store choices in state for reliable mapping
+                p0_choices = legal_p0  # [(action_id, label), ...]
+                p1_choices = legal_p1  # [(action_id, label), ...]
+
+                # For Gradio dropdowns: use (label, value) pairs so user sees labels but selects action IDs
+                p0_dropdown_choices = [(label, action_id) for action_id, label in p0_choices]
+                p1_dropdown_choices = [(label, action_id) for action_id, label in p1_choices]
+
+                # Show/hide dropdowns based on whether each player is human
+                p0_is_human = (p1_key == "human")
+                p1_is_human = (p2_key == "human")
 
                 return (
                     state,  # game_state
+                    p0_choices,  # human_choices_p0
+                    p1_choices,  # human_choices_p1
                     log,    # board_display
-                    gr.update(choices=p0_choices, visible=len(p0_choices) > 0, value=None),  # p0_move_dropdown
-                    gr.update(choices=p1_choices, visible=len(p1_choices) > 0, value=None),  # p1_move_dropdown
-                    gr.update(visible=True),  # submit_move_btn
+                    gr.update(choices=p0_dropdown_choices, visible=p0_is_human, value=None),  # human_move_p0
+                    gr.update(choices=p1_dropdown_choices, visible=p1_is_human, value=None),  # human_move_p1
+                    gr.update(visible=True),  # submit_btn
                     gr.update(visible=True),  # reset_game_btn
                 )
             except Exception as e:
                 return (
                     None,   # game_state
+                    [],     # human_choices_p0
+                    [],     # human_choices_p1
                     f"Error starting interactive game: {e}",  # board_display
-                    gr.update(choices=[], visible=False),     # p0_move_dropdown
-                    gr.update(choices=[], visible=False),     # p1_move_dropdown
-                    gr.update(visible=False),                 # submit_move_btn
+                    gr.update(choices=[], visible=False),     # human_move_p0
+                    gr.update(choices=[], visible=False),     # human_move_p1
+                    gr.update(visible=False),                 # submit_btn
                     gr.update(visible=False),                 # reset_game_btn
                 )
 
-        def submit_human_move_handler(p0_action, p1_action, state):
+        def submit_human_move_handler(p0_action, p1_action, state, choices_p0, choices_p1):
             """Process human moves and advance the game."""
             try:
                 from ui.gradio_config_generator import submit_human_move
 
                 if not state:
-                    return state, "No game running.", gr.update(choices=[], visible=False), gr.update(choices=[], visible=False), gr.update(visible=False), gr.update(visible=False)
+                    return (
+                        state, [], [], "No game running.",
+                        gr.update(choices=[], visible=False),
+                        gr.update(choices=[], visible=False),
+                        gr.update(visible=False),
+                        gr.update(visible=False)
+                    )
 
+                # p0_action and p1_action are now directly the integer action IDs from dropdown
                 log_append, new_state, next_p0, next_p1 = submit_human_move(
                     action_p0=p0_action,
                     action_p1=p1_action,
                     state=state,
                 )
 
-                # Update dropdowns with next legal actions
-                p0_choices = [(action, label) for action, label in next_p0]
-                p1_choices = [(action, label) for action, label in next_p1]
+                # Store new choices in state
+                new_choices_p0 = next_p0  # [(action_id, label), ...]
+                new_choices_p1 = next_p1  # [(action_id, label), ...]
+
+                # Convert to Gradio dropdown format: (label, value) pairs
+                p0_dropdown_choices = [(label, action_id) for action_id, label in new_choices_p0]
+                p1_dropdown_choices = [(label, action_id) for action_id, label in new_choices_p1]
 
-                # Check if game is finished
-                game_over = new_state.get("terminated", False) or new_state.get("truncated", False)
+                # Check if game is finished (no more legal actions)
+                game_over = (new_state.get("terminated", False) or
+                           new_state.get("truncated", False) or
+                           (len(new_choices_p0) == 0 and len(new_choices_p1) == 0))
 
                 return (
                     new_state,  # game_state
+                    new_choices_p0,  # human_choices_p0
+                    new_choices_p1,  # human_choices_p1
                     log_append,  # board_display (append to current)
-                    gr.update(choices=p0_choices, visible=len(p0_choices) > 0 and not game_over, value=None),  # p0_move_dropdown
-                    gr.update(choices=p1_choices, visible=len(p1_choices) > 0 and not game_over, value=None),  # p1_move_dropdown
-                    gr.update(visible=not game_over),  # submit_move_btn
+                    gr.update(choices=p0_dropdown_choices, visible=len(p0_dropdown_choices) > 0 and not game_over, value=None),  # human_move_p0
+                    gr.update(choices=p1_dropdown_choices, visible=len(p1_dropdown_choices) > 0 and not game_over, value=None),  # human_move_p1
+                    gr.update(visible=not game_over),  # submit_btn
                     gr.update(visible=True),           # reset_game_btn (always visible to restart)
                 )
             except Exception as e:
-                return state, f"Error processing move: {e}", gr.update(), gr.update(), gr.update(), gr.update()
+                return (
+                    state, choices_p0, choices_p1, f"Error processing move: {e}",
+                    gr.update(), gr.update(), gr.update(), gr.update()
+                )
 
         def reset_interactive_game():
             """Reset the interactive game state."""
             return (
                 None,  # game_state
+                [],    # human_choices_p0
+                [],    # human_choices_p1
                 "Game reset. Click 'Start Interactive Game' to begin a new game.",  # board_display
-                gr.update(choices=[], visible=False),  # p0_move_dropdown
-                gr.update(choices=[], visible=False),  # p1_move_dropdown
-                gr.update(visible=False),              # submit_move_btn
+                gr.update(choices=[], visible=False),  # human_move_p0
+                gr.update(choices=[], visible=False),  # human_move_p1
+                gr.update(visible=False),              # submit_btn
                 gr.update(visible=False),              # reset_game_btn
             )
 
         # Wire up interactive game handlers
-        start_interactive_btn.click(
+        start_btn.click(
             start_interactive_game,
             inputs=[game_dropdown, p1_type, p2_type, p1_model, p2_model, rounds_slider],
-            outputs=[game_state, board_display, p0_move_dropdown, p1_move_dropdown, submit_move_btn, reset_game_btn],
+            outputs=[game_state, human_choices_p0, human_choices_p1, board_display, human_move_p0, human_move_p1, submit_btn, reset_game_btn],
         )
 
-        submit_move_btn.click(
+        submit_btn.click(
             submit_human_move_handler,
-            inputs=[p0_move_dropdown, p1_move_dropdown, game_state],
-            outputs=[game_state, board_display, p0_move_dropdown, p1_move_dropdown, submit_move_btn, reset_game_btn],
+            inputs=[human_move_p0, human_move_p1, game_state, human_choices_p0, human_choices_p1],
+            outputs=[game_state, human_choices_p0, human_choices_p1, board_display, human_move_p0, human_move_p1, submit_btn, reset_game_btn],
         )
 
         reset_game_btn.click(
             reset_interactive_game,
-            outputs=[game_state, board_display, p0_move_dropdown, p1_move_dropdown, submit_move_btn, reset_game_btn],
+            outputs=[game_state, human_choices_p0, human_choices_p1, board_display, human_move_p0, human_move_p1, submit_btn, reset_game_btn],
         )
 
     with gr.Tab("Leaderboard"):