Update app.py

app.py

@@ -4,17 +4,17 @@ import time
 from datetime import datetime
 import base64
 
-# App Title and Config
+# --- App Title and Config ---
 st.set_page_config(page_title="Gamuu", page_icon="🎮", layout="wide")
 st.title("🎮 Gamuu - Ultimate Connection Game")
 
-# Initialize Session State
+# --- Initialize Session State (with some additions for robustness) ---
 if 'registered' not in st.session_state:
-    st.session_state.registered = False
+    st.session_state.registered = False # True if at least one player is registered
 if 'players' not in st.session_state:
-    st.session_state.players = {}
+    st.session_state.players = {} # {name: {details}}
 if 'teams' not in st.session_state:
-    st.session_state.teams = {}
+    st.session_state.teams = {} # {team_name: [player_name1, player_name2]} - for multi-player teams
 if 'questions' not in st.session_state:
     st.session_state.questions = {
         'Music': [
@@ -336,7 +336,7 @@ if 'questions' not in st.session_state:
             "What's your favorite food to eat at a festival?",
             "What's your favorite food to eat at a theme park?",
             "What's your favorite food to eat at a concert?",
-            "What's your favorite food to eat at a sporting event?",
+            "What's_your favorite food to eat at a sporting event?",
             "What's your favorite food to eat at a carnival?",
             "What's your favorite food to eat at a fair?",
             "What's your favorite food to eat at a holiday gathering?",
@@ -411,7 +411,7 @@ if 'questions' not in st.session_state:
 if 'points' not in st.session_state:
     st.session_state.points = {}  # Individual player points
 if 'team_points' not in st.session_state:
-    st.session_state.team_points = {}  # Team points
+    st.session_state.team_points = {}  # Team points (for multi-player teams)
 if 'feedback' not in st.session_state:
     st.session_state.feedback = []
 if 'suggestions' not in st.session_state:
@@ -422,10 +422,12 @@ if 'question' not in st.session_state:
     st.session_state.question = None
 if 'timer_start' not in st.session_state:
     st.session_state.timer_start = None
+if 'timer_instance_key' not in st.session_state: # Key for HTML timer component
+    st.session_state.timer_instance_key = "timer_initial"
 if 'achievements' not in st.session_state:
-    st.session_state.achievements = {}
+    st.session_state.achievements = {} # {player_name: [achievement1, ...]}
 if 'timeouts' not in st.session_state:
-    st.session_state.timeouts = {}
+    st.session_state.timeouts = {} # {player_name: count}
 if 'admin' not in st.session_state:
     st.session_state.admin = False
 if 'round' not in st.session_state:
@@ -436,7 +438,7 @@ if 'penalty_threshold' not in st.session_state:
     st.session_state.penalty_threshold = 3
 if 'game_paused' not in st.session_state:
     st.session_state.game_paused = False
-if 'available_categories' not in st.session_state:
+if 'available_categories' not in st.session_state: # Categories chosen by at least one player
     st.session_state.available_categories = []
 if 'theme' not in st.session_state:
     st.session_state.theme = "Light"
@@ -449,7 +451,7 @@ if 'current_category_index' not in st.session_state:
 if 'round_start_time' not in st.session_state:
     st.session_state.round_start_time = None
 
-# Theme CSS
+# --- Theme CSS ---
 def apply_theme():
     if st.session_state.theme == "Dark":
         st.markdown("""
@@ -474,69 +476,98 @@ def apply_theme():
             <style>
             body { background-color: #ffffff; color: #000000; }
             .stApp { background-color: #ffffff; color: #000000; }
+            /* You might want to remove button styling for light theme or make it default */
             </style>
         """, unsafe_allow_html=True)
 
-# Non-blocking Timer HTML
+# --- Non-blocking Timer HTML ---
 timer_html = """
 <script>
-let timeLeft = 30;
-let timer = setInterval(() => {
-    if (timeLeft > 0 && !window.paused) {
-        timeLeft--;
-        document.getElementById("timer").innerHTML = `⏳ Time Remaining: ${timeLeft}s`;
-        document.getElementById("progress").value = 30 - timeLeft;
-    } else if (timeLeft <= 0) {
-        clearInterval(timer);
-        document.getElementById("timer").innerHTML = "⏰ Time's up!";
-    }
-}, 1000);
-
-function pauseTimer() {
-    window.paused = true;
+let timeLeft = 30; // This will be visually reset, but actual timeout is Python-driven
+let timerInterval; // Store interval ID to clear it
+
+function startTimer() {
+    clearInterval(timerInterval); // Clear any existing timer
+    timeLeft = 30; // Reset time
+    document.getElementById("timer").innerHTML = `⏳ Time Remaining: ${timeLeft}s`;
+    document.getElementById("progress").value = 0;
+
+    timerInterval = setInterval(() => {
+        if (timeLeft > 0 && !window.gamuuPaused) { // Check a global pause flag
+            timeLeft--;
+            document.getElementById("timer").innerHTML = `⏳ Time Remaining: ${timeLeft}s`;
+            document.getElementById("progress").value = 30 - timeLeft;
+        } else if (timeLeft <= 0) {
+            clearInterval(timerInterval);
+            document.getElementById("timer").innerHTML = "⏰ Time's up!";
+        }
+    }, 1000);
 }
 
-function resumeTimer() {
-    window.paused = false;
-}
+// Functions to be called by Streamlit via st.components.v1.html
+window.pauseGamuuTimer = function() { window.gamuuPaused = true; }
+window.resumeGamuuTimer = function() { window.gamuuPaused = false; }
+
+// Start timer on initial load of this component
+// This script block re-runs when the component is re-rendered with a new key.
+startTimer();
 </script>
 <div id="timer">⏳ Time Remaining: 30s</div>
-<progress id="progress" value="0" max="30"></progress>
+<progress id="progress" value="0" max="30" style="width: 100%;"></progress>
 """
 
-# Sidebar - Registration and Socials
+# --- Helper to get registered players for selectboxes ---
+def get_registered_player_names():
+    return list(st.session_state.players.keys()) if st.session_state.players else []
+
+# --- Sidebar ---
 with st.sidebar:
     st.header("🚀 Player Registration")
-    with st.form("registration"):
-        player_name = st.text_input("Your Name")
-        team_name = st.text_input("Team Name (leave blank for solo)")
-        all_categories = ['Music', 'Love Language', 'Movies', 'Activities', '18+', 'Travel', 'Food', 'Personal Growth', 'Dare']
-        categories = st.multiselect("Choose Categories", all_categories, key=f"categories_{len(st.session_state.players)}")
-        avatar_file = st.file_uploader("Upload Avatar (optional)", type=["png", "jpg", "jpeg"])
-        submitted = st.form_submit_button("Join Game")
-        if submitted and player_name:
-            avatar_data = avatar_file.read() if avatar_file else None
-            st.session_state.players[player_name] = {
-                'categories': categories,
-                'joined': datetime.now(),
-                'team': team_name if team_name else player_name,
-                'avatar': base64.b64encode(avatar_data).decode('utf-8') if avatar_data else None
-            }
-            st.session_state.points[player_name] = 0
-            st.session_state.timeouts[player_name] = 0
-            if team_name:
-                if team_name not in st.session_state.teams:
-                    st.session_state.teams[team_name] = []
-                    st.session_state.team_points[team_name] = 0
-                st.session_state.teams[team_name].append(player_name)
-            st.session_state.registered = True
-            st.session_state.available_categories = list(set().union(*[p['categories'] for p in st.session_state.players.values()]))
-            st.success(f"Welcome {player_name}! You've joined the game.")
-            st.rerun()
+    with st.form("registration_form"): # Added form key
+        player_name_input = st.text_input("Your Name")
+        team_name_input = st.text_input("Team Name (leave blank for solo)")
+        all_categories_list = ['Music', 'Love Language', 'Movies', 'Activities', '18+', 'Travel', 'Food', 'Personal Growth', 'Dare']
+        # Use a dynamic key for multiselect to avoid issues if players have same name (though names are keys now)
+        categories_selected = st.multiselect("Choose Categories", all_categories_list, key=f"categories_input_{len(st.session_state.players)}")
+        avatar_file_uploaded = st.file_uploader("Upload Avatar (optional)", type=["png", "jpg", "jpeg"])
+        submitted_registration = st.form_submit_button("Join Game")
+
+        if submitted_registration and player_name_input:
+            if player_name_input in st.session_state.players:
+                st.error(f"Player name '{player_name_input}' already taken!")
+            else:
+                avatar_data_bytes = avatar_file_uploaded.read() if avatar_file_uploaded else None
+                player_team_key = team_name_input if team_name_input else player_name_input # Player's own name if solo
+
+                st.session_state.players[player_name_input] = {
+                    'categories': categories_selected,
+                    'joined': datetime.now(),
+                    'team': player_team_key,
+                    'avatar': base64.b64encode(avatar_data_bytes).decode('utf-8') if avatar_data_bytes else None
+                }
+                st.session_state.points[player_name_input] = 0
+                st.session_state.timeouts[player_name_input] = 0
+
+                if team_name_input: # If it's a multi-player team
+                    if team_name_input not in st.session_state.teams:
+                        st.session_state.teams[team_name_input] = []
+                        st.session_state.team_points[team_name_input] = 0 # Initialize points for new multi-player team
+                    st.session_state.teams[team_name_input].append(player_name_input)
+
+                st.session_state.registered = True # At least one player is now registered
+                
+                # Update available_categories based on ALL registered players
+                all_player_categories = set()
+                for p_data in st.session_state.players.values():
+                    all_player_categories.update(p_data['categories'])
+                st.session_state.available_categories = sorted(list(all_player_categories)) # Sorted for consistent order
+
+                st.success(f"Welcome {player_name_input}! You've joined the game.")
+                st.rerun() # Rerun to update UI elements that depend on player list
 
     st.header("🎨 Theme Selection")
-    st.session_state.theme = st.selectbox("Choose Theme", ["Light", "Dark", "Retro"], index=["Light", "Dark", "Retro"].index(st.session_state.theme))
-    apply_theme()
+    st.session_state.theme = st.selectbox("Choose Theme", ["Light", "Dark", "Retro"], index=["Light", "Dark", "Retro"].index(st.session_state.theme), key="theme_selector")
+    apply_theme() # Apply theme immediately
 
     st.header("📱 Social Connect")
     st.write("🔗 [Instagram](https://instagram.com) | [Twitter](https://twitter.com)")
@@ -544,265 +575,443 @@ with st.sidebar:
 
     st.header("💡 Feedback & Suggestions")
     with st.form("feedback_form"):
-        feedback = st.text_area("Share your experience or suggest improvements")
+        feedback_text = st.text_area("Share your experience or suggest improvements")
+        feedback_player_name = st.selectbox("Submitting as:", get_registered_player_names(), key="feedback_player", help="Select your player name.")
         if st.form_submit_button("Submit Feedback"):
-            if player_name:
-                st.session_state.feedback.append(feedback)
-                st.session_state.points[player_name] += 5
-                st.success("Thanks for your feedback! +5 points")
+            if feedback_player_name and feedback_text: # Check if a player is selected and text is provided
+                st.session_state.feedback.append({'player': feedback_player_name, 'feedback': feedback_text, 'time': datetime.now()})
+                st.session_state.points[feedback_player_name] = st.session_state.points.get(feedback_player_name, 0) + 5
+                st.success(f"Thanks for your feedback, {feedback_player_name}! +5 points")
+                st.rerun()
+            elif not feedback_player_name:
+                st.error("Please select your player name to submit feedback.")
             else:
-                st.error("Please register first!")
+                st.error("Please write some feedback before submitting.")
+
 
     st.header("🔒 Admin Login")
-    admin_password = st.text_input("Admin Password", type="password")
-    if st.button("Login as Admin"):
-        if admin_password == "admin123":  # Replace with a secure method
+    admin_password_input = st.text_input("Admin Password", type="password", key="admin_pass")
+    if st.button("Login as Admin", key="admin_login_btn"):
+        if admin_password_input == "admin123":  # Replace with a secure method (e.g., Streamlit Secrets)
             st.session_state.admin = True
             st.success("Admin login successful!")
+            st.rerun()
         else:
             st.error("Incorrect password.")
 
-# Admin Dashboard
+# --- Admin Dashboard (if logged in) ---
 if st.session_state.admin:
     st.sidebar.header("🔧 Admin Dashboard")
     admin_tab1, admin_tab2 = st.sidebar.tabs(["Manage Questions", "Game Settings"])
 
     with admin_tab1:
         st.subheader("Add New Question")
-        with st.form("add_question"):
-            category = st.selectbox("Category", list(st.session_state.questions.keys()))
-            new_question = st.text_input("New Question")
+        with st.form("add_question_form"):
+            add_q_category = st.selectbox("Category", list(st.session_state.questions.keys()), key="admin_add_cat")
+            add_q_subcategory = None
+            if isinstance(st.session_state.questions.get(add_q_category), dict):
+                add_q_subcategory = st.selectbox("Subcategory", list(st.session_state.questions[add_q_category].keys()), key="admin_add_subcat")
+            
+            new_question_text = st.text_input("New Question", key="admin_new_q_text")
             if st.form_submit_button("Add Question"):
-                if category in st.session_state.questions:
-                    if isinstance(st.session_state.questions[category], dict):
-                        subcategory = st.selectbox("Subcategory", list(st.session_state.questions[category].keys()))
-                        st.session_state.questions[category][subcategory].append(new_question)
+                if new_question_text:
+                    if add_q_subcategory:
+                        st.session_state.questions[add_q_category][add_q_subcategory].append(new_question_text)
+                    elif add_q_category in st.session_state.questions and isinstance(st.session_state.questions[add_q_category], list):
+                        st.session_state.questions[add_q_category].append(new_question_text)
                     else:
-                        st.session_state.questions[category].append(new_question)
+                         st.error(f"Cannot add question to category '{add_q_category}' structure.") # Should not happen with current setup
                     st.success("Question added successfully!")
                 else:
-                    st.error("Category not found.")
+                    st.error("Question text cannot be empty.")
 
         st.subheader("Remove Question")
-        with st.form("remove_question"):
-            category = st.selectbox("Category to Remove From", list(st.session_state.questions.keys()))
-            if isinstance(st.session_state.questions[category], dict):
-                subcategory = st.selectbox("Subcategory", list(st.session_state.questions[category].keys()))
-                question_to_remove = st.selectbox("Question to Remove", st.session_state.questions[category][subcategory])
-            else:
-                question_to_remove = st.selectbox("Question to Remove", st.session_state.questions[category])
-            if st.form_submit_button("Remove Question"):
-                if isinstance(st.session_state.questions[category], dict):
-                    st.session_state.questions[category][subcategory].remove(question_to_remove)
-                else:
-                    st.session_state.questions[category].remove(question_to_remove)
-                st.success("Question removed successfully!")
+        with st.form("remove_question_form"):
+            rem_q_category = st.selectbox("Category to Remove From", list(st.session_state.questions.keys()), key="admin_rem_cat")
+            rem_q_subcategory = None
+            questions_for_removal = []
+
+            if rem_q_category in st.session_state.questions:
+                if isinstance(st.session_state.questions[rem_q_category], dict):
+                    rem_q_subcategory = st.selectbox("Subcategory", list(st.session_state.questions[rem_q_category].keys()), key="admin_rem_subcat")
+                    if rem_q_subcategory and rem_q_subcategory in st.session_state.questions[rem_q_category]:
+                        questions_for_removal = st.session_state.questions[rem_q_category][rem_q_subcategory]
+                elif isinstance(st.session_state.questions[rem_q_category], list):
+                    questions_for_removal = st.session_state.questions[rem_q_category]
+            
+            question_to_remove_text = st.selectbox("Question to Remove", questions_for_removal, key="admin_rem_q_select", disabled=not questions_for_removal)
+            
+            if st.form_submit_button("Remove Question", disabled=not question_to_remove_text):
+                try:
+                    if rem_q_subcategory:
+                        st.session_state.questions[rem_q_category][rem_q_subcategory].remove(question_to_remove_text)
+                    else:
+                        st.session_state.questions[rem_q_category].remove(question_to_remove_text)
+                    st.success("Question removed successfully!")
+                    st.rerun() # To update the selectbox
+                except ValueError:
+                    st.error("Question not found for removal (should not happen with selectbox).")
+                except Exception as e:
+                    st.error(f"Error removing question: {e}")
+
 
     with admin_tab2:
         st.subheader("Game Settings")
-        penalty_threshold = st.number_input("Penalty Threshold", min_value=1, value=st.session_state.penalty_threshold)
-        dare_frequency = st.number_input("Dare Frequency (Rounds)", min_value=1, value=st.session_state.dare_frequency)
-        if st.button("Save Settings"):
-            st.session_state.penalty_threshold = penalty_threshold
-            st.session_state.dare_frequency = dare_frequency
-            st.success(f"Settings saved! Penalty Threshold: {penalty_threshold}, Dare Frequency: every {dare_frequency} rounds.")
-
-# Main Game Interface
+        penalty_threshold_input = st.number_input("Penalty Threshold (Timeouts)", min_value=1, value=st.session_state.penalty_threshold, key="admin_penalty")
+        dare_frequency_input = st.number_input("Dare Frequency (every N rounds)", min_value=1, value=st.session_state.dare_frequency, key="admin_dare_freq")
+        if st.button("Save Settings", key="admin_save_settings"):
+            st.session_state.penalty_threshold = penalty_threshold_input
+            st.session_state.dare_frequency = dare_frequency_input
+            st.success(f"Settings saved! Penalty Threshold: {penalty_threshold_input}, Dare Frequency: every {dare_frequency_input} rounds.")
+
+# --- Main Game Interface ---
 tab1, tab2, tab3, tab4 = st.tabs(["🎯 Game Zone", "🏆 Leaderboard", "🎁 Redeem Points", "🌟 Achievements"])
 
 with tab1:
-    if st.session_state.registered:
+    if st.session_state.registered: # Only show game zone if players are registered
         st.header("🌟 Current Round")
         col1, col2 = st.columns([3, 2])
-        players = list(st.session_state.players.keys())
+        current_registered_players = get_registered_player_names()
 
         with col1:
-            if st.button("⏸️ Pause Game" if not st.session_state.game_paused else "▶️ Resume Game"):
+            if st.button("⏸️ Pause Game" if not st.session_state.game_paused else "▶️ Resume Game", key="pause_resume_btn"):
                 st.session_state.game_paused = not st.session_state.game_paused
                 if st.session_state.game_paused:
                     st.warning("Game Paused!")
-                    st.components.v1.html("<script>pauseTimer();</script>", height=0)
+                    st.components.v1.html("<script>window.pauseGamuuTimer();</script>", height=0)
                 else:
                     st.success("Game Resumed!")
-                    st.components.v1.html("<script>resumeTimer();</script>", height=0)
+                    st.components.v1.html("<script>window.resumeGamuuTimer();</script>", height=0)
+                st.rerun()
+
 
             if not st.session_state.game_paused:
-                # Round Timer (5 minutes = 300 seconds)
+                # Round Timer (5 minutes = 300 seconds) - This is an overall round timer, not per question
                 if st.session_state.round_start_time is None:
                     st.session_state.round_start_time = time.time()
-                round_time_left = 300 - int(time.time() - st.session_state.round_start_time)
+                
+                round_elapsed_time = int(time.time() - st.session_state.round_start_time)
+                round_time_limit = 300 # 5 minutes
+                round_time_left = round_time_limit - round_elapsed_time
+
                 if round_time_left <= 0:
+                    st.warning("Round time limit reached! Resetting for a new round.")
                     st.session_state.current_player = None
                     st.session_state.question = None
-                    st.session_state.timer_start = None
-                    st.session_state.round_start_time = time.time()
+                    st.session_state.timer_start = None # Reset question timer
+                    st.session_state.round_start_time = time.time() # Reset round timer
                     st.session_state.question_count = 0
                     st.session_state.current_category_index = 0
-                    st.warning("Round ended! Moving to next round.")
-
-                st.write(f"⏳ Round Time Left: {round_time_left}s")
-
-                # Category Cycling
-                available_categories = st.session_state.available_categories
-                if st.session_state.question_count >= 9 and len(available_categories) > 1:
-                    st.session_state.current_category_index = (st.session_state.current_category_index + 1) % len(available_categories)
-                    st.session_state.question_count = 0
-                    st.success(f"Switching to category: {available_categories[st.session_state.current_category_index]}")
+                    # Potentially add more logic here like ending the game or auto-advancing
+                    st.rerun()
+                else:
+                    st.write(f"⏳ Overall Round Time Left: {round_time_left // 60}m {round_time_left % 60}s")
+
+
+                # Category Cycling Logic
+                if st.session_state.available_categories: # Only if there are categories to cycle through
+                    if st.session_state.question_count >= 9 and len(st.session_state.available_categories) > 1:
+                        st.session_state.current_category_index = (st.session_state.current_category_index + 1) % len(st.session_state.available_categories)
+                        st.session_state.question_count = 0
+                        st.success(f"Switching to category: {st.session_state.available_categories[st.session_state.current_category_index]}")
+                        st.rerun() # Rerun to reflect new category selection
+
+                    # Ensure current_category_index is valid
+                    if st.session_state.current_category_index >= len(st.session_state.available_categories):
+                        st.session_state.current_category_index = 0
+                    
+                    category_options_for_select = st.session_state.available_categories + ['Random']
+                    try:
+                        default_cat_index = category_options_for_select.index(st.session_state.available_categories[st.session_state.current_category_index])
+                    except (IndexError, ValueError): # If index is bad or category not found (e.g. available_categories empty)
+                        default_cat_index = len(category_options_for_select) -1 # Default to Random
+
+                    selected_category_name = st.selectbox("Choose Question Category",
+                        category_options_for_select, index=default_cat_index, key="category_select")
+                else:
+                    selected_category_name = st.selectbox("Choose Question Category", ['Random'], key="category_select_norandom") # Only random if no categories
+                    st.info("No specific categories selected by players. Defaulting to Random from all questions.")
 
-                selected_category = st.selectbox("Choose Question Category",
-                    available_categories + ['Random'], index=st.session_state.current_category_index)
 
-                if selected_category == '18+' and '18+' in available_categories:
-                    spice_level = st.select_slider("🌶️ Spice Level",
-                        options=['Spicy', 'Extra Spicy', 'Space Spicy', 'Hardcore'])
+                spice_level_selection = None
+                if selected_category_name == '18+' and '18+' in st.session_state.available_categories:
+                    spice_level_selection = st.select_slider("🌶️ Spice Level",
+                        options=['Spicy', 'Extra Spicy', 'Space Spicy', 'Hardcore'], key="spice_slider")
 
-                if st.button("🌀 Spin the Bottle", use_container_width=True):
-                    if len(players) > 1:
-                        st.session_state.current_player = random.choice(players)
-                        st.session_state.timer_start = time.time()
+                if st.button("🌀 Spin the Bottle", use_container_width=True, key="spin_bottle_btn", disabled=len(current_registered_players) < 1):
+                    if current_registered_players: # Ensure there are players
+                        st.session_state.current_player = random.choice(current_registered_players)
+                        st.session_state.timer_start = time.time() # Start of question timer
                         st.session_state.round += 1
                         st.session_state.question_count += 1
+                        # Update timer key to force JS timer reset
+                        st.session_state.timer_instance_key = f"timer_q_{st.session_state.round}_{st.session_state.current_player}"
 
-                        if selected_category == '18+':
-                            st.session_state.question = random.choice(st.session_state.questions['18+'][spice_level])
-                        elif selected_category == 'Random':
-                            category = random.choice(available_categories)
-                            if isinstance(st.session_state.questions[category], dict):
-                                subcategory = random.choice(list(st.session_state.questions[category].keys()))
-                                st.session_state.question = random.choice(st.session_state.questions[category][subcategory])
-                            else:
-                                st.session_state.question = random.choice(st.session_state.questions[category])
+
+                        potential_questions = []
+                        chosen_category_for_question = selected_category_name
+
+                        # Dare logic
+                        is_dare_round = (st.session_state.round % st.session_state.dare_frequency == 0 and
+                                         'Dare' in st.session_state.available_categories and
+                                         st.session_state.questions.get('Dare'))
+                        if is_dare_round:
+                            potential_questions = st.session_state.questions['Dare']
+                            chosen_category_for_question = "Dare"
                         else:
-                            st.session_state.question = random.choice(st.session_state.questions[selected_category])
+                            if selected_category_name == '18+' and spice_level_selection:
+                                if '18+' in st.session_state.questions and \
+                                   spice_level_selection in st.session_state.questions['18+']:
+                                    potential_questions = st.session_state.questions['18+'][spice_level_selection]
+                                else:
+                                    st.warning(f"No questions found for 18+ {spice_level_selection}. Check admin setup.")
+                            elif selected_category_name == 'Random':
+                                all_q_lists = []
+                                for cat_key, cat_value in st.session_state.questions.items():
+                                    if isinstance(cat_value, list) and cat_value:
+                                        all_q_lists.append(cat_value)
+                                    elif isinstance(cat_value, dict): # e.g., 18+
+                                        for sub_cat_list in cat_value.values():
+                                            if sub_cat_list:
+                                                all_q_lists.append(sub_cat_list)
+                                if all_q_lists:
+                                    random_list_choice = random.choice(all_q_lists)
+                                    potential_questions = random_list_choice
+                                    # Finding the name of the randomly chosen category is complex, skip for now for question text
+                                    chosen_category_for_question = "Random Mix"
+                                else:
+                                    st.warning("No questions available in any category for Random selection.")
+                            elif selected_category_name in st.session_state.questions and st.session_state.questions[selected_category_name]:
+                                potential_questions = st.session_state.questions[selected_category_name]
+                            else:
+                                st.warning(f"No questions found for category '{selected_category_name}'.")
 
-                        if st.session_state.round % st.session_state.dare_frequency == 0 and 'Dare' in available_categories:
-                            st.session_state.question = random.choice(st.session_state.questions['Dare'])
+                        if potential_questions:
+                            st.session_state.question = random.choice(potential_questions)
+                            st.success(f"🎯 {st.session_state.current_player}, it's your turn! ({chosen_category_for_question})")
+                        else:
+                            st.session_state.question = "Oops! No questions found for this selection. Admin might need to add some or check category choices."
+                            st.session_state.current_player = None # Can't proceed
+                            st.session_state.timer_start = None
+                        st.rerun()
 
-                        st.success(f"🎯 {st.session_state.current_player}, it's your turn!")
-                        st.session_state.round_start_time = time.time() if st.session_state.round_start_time is None else st.session_state.round_start_time
                     else:
                         st.error("Not enough players to spin the bottle!")
+            else: # Game Paused
+                 st.info("Game is paused. Press Resume to continue.")
 
+
+        # --- Display Current Player, Question, Timer (col2) ---
         if st.session_state.current_player and st.session_state.question and not st.session_state.game_paused:
             with col2:
-                player_avatar = st.session_state.players[st.session_state.current_player]['avatar']
-                if player_avatar:
-                    st.image(f"data:image/png;base64,{player_avatar}", width=100)
-                st.subheader(f"🎯 Current Player: {st.session_state.current_player}")
-                st.subheader("❓ Your Question:")
-                st.write(f"**{st.session_state.question}**")
-
-                # Non-blocking Timer
-                timer_placeholder = st.components.v1.html(timer_html, height=70)
-                if st.session_state.timer_start and time.time() - st.session_state.timer_start >= 30:
-                    st.error("⏰ Time's up! Points deducted")
-                    st.session_state.points[st.session_state.current_player] -= 10
-                    st.session_state.timeouts[st.session_state.current_player] += 1
-                    st.session_state.timer_start = None
-
-                # Penalty System
-                if st.session_state.timeouts[st.session_state.current_player] >= st.session_state.penalty_threshold:
-                    st.error(f"{st.session_state.current_player} has timed out too many times and is penalized!")
-                    savior = st.selectbox("Choose a Savior", [p for p in players if p != st.session_state.current_player])
-                    ultimate_question = random.choice(st.session_state.questions['18+']['Hardcore'])
-                    st.write(f"{savior}, answer this ultimate question to save {st.session_state.current_player}:")
-                    st.write(f"**{ultimate_question}**")
-                    if st.button("Submit Answer"):
-                        st.success(f"{savior} has saved {st.session_state.current_player}!")
-                        st.session_state.timeouts[st.session_state.current_player] = 0
-
-                if st.button("✅ Submit Answer", key="answer_submit"):
-                    time_taken = int(time.time() - st.session_state.timer_start)
-                    points = max(50 - time_taken, 10)
-                    st.session_state.points[st.session_state.current_player] += points
-                    team = st.session_state.players[st.session_state.current_player]['team']
-                    if team != st.session_state.current_player:  # If part of a team
-                        st.session_state.team_points[team] += points
-                    st.success(f"🎉 Answer accepted! +{points} points")
-                    st.session_state.current_player = None
-                    st.session_state.question = None
-                    st.session_state.timer_start = None
+                player_details = st.session_state.players.get(st.session_state.current_player)
+                if player_details and player_details.get('avatar'):
+                    try:
+                        st.image(f"data:image/png;base64,{player_details['avatar']}", width=100, caption=st.session_state.current_player)
+                    except Exception as e:
+                        st.caption(f"{st.session_state.current_player} (avatar error)")
+                else:
+                     st.subheader(f"🎯 Current Player: {st.session_state.current_player}")
 
+                st.subheader("❓ Your Question:")
+                st.markdown(f"**{st.session_state.question}**")
+
+                # Non-blocking Timer - Python logic for timeout is primary
+                st.components.v1.html(timer_html, height=80, key=st.session_state.timer_instance_key) # Unique key forces re-render
+
+                if st.session_state.timer_start and (time.time() - st.session_state.timer_start >= 30):
+                    st.error("⏰ Time's up! Points deducted.")
+                    st.session_state.points[st.session_state.current_player] = st.session_state.points.get(st.session_state.current_player, 0) - 10
+                    st.session_state.timeouts[st.session_state.current_player] = st.session_state.timeouts.get(st.session_state.current_player, 0) + 1
+                    st.session_state.timer_start = None # Reset timer for next turn logic
+                    st.session_state.question = None # Clear question
+                    # Check for penalty after timeout
+                    current_player_timeouts = st.session_state.timeouts.get(st.session_state.current_player, 0)
+                    if current_player_timeouts >= st.session_state.penalty_threshold:
+                         st.warning(f"{st.session_state.current_player} has timed out {current_player_timeouts} times and is penalized!")
+                         # Penalty logic will be handled below, rerun to show it
+                    st.session_state.current_player = None # End turn
+                    st.rerun()
+
+                # Penalty System (if current_player was set and timed out previously, or just timed out now)
+                # This needs to be accessible even if the question timed out, so check before the "Submit Answer" button
+                penalized_player = None
+                for p_name, t_outs in st.session_state.timeouts.items():
+                    if t_outs >= st.session_state.penalty_threshold:
+                        penalized_player = p_name
+                        break # Handle one penalty at a time for simplicity
+
+                if penalized_player and penalized_player == st.session_state.current_player: # Only if it's the current player's turn for this penalty UI
+                    st.error(f"🚨 PENALTY! {penalized_player} has timed out too many times.")
+                    eligible_saviors = [p for p in current_registered_players if p != penalized_player]
+                    if eligible_saviors:
+                        savior_name = st.selectbox(f"Choose a Savior for {penalized_player}", eligible_saviors, key=f"savior_{penalized_player}")
+                        hardcore_questions = st.session_state.questions.get('18+', {}).get('Hardcore', [])
+                        if hardcore_questions:
+                            ultimate_question_text = random.choice(hardcore_questions)
+                            st.write(f"🦸 {savior_name}, answer this ultimate question to save {penalized_player}:")
+                            st.write(f"**{ultimate_question_text}**")
+                            if st.button(f"Submit Savior Answer for {penalized_player}", key=f"savior_submit_{penalized_player}"):
+                                st.success(f"{savior_name} has saved {penalized_player}! Penalty reset.")
+                                st.session_state.timeouts[penalized_player] = 0
+                                # Award points to savior?
+                                st.session_state.points[savior_name] = st.session_state.points.get(savior_name,0) + 20
+                                st.session_state.current_player = None # End penalized player's effective turn
+                                st.session_state.question = None
+                                st.rerun()
+                        else:
+                            st.warning("No 'Hardcore' questions available for savior task. Penalty waived for now.")
+                            st.session_state.timeouts[penalized_player] = 0
+                            st.rerun()
+                    else:
+                        st.warning(f"No saviors available for {penalized_player}. Penalty remains, but consider waiving.")
+                        # Decide: st.session_state.timeouts[penalized_player] = 0 # or keep penalty
+
+                # Only show submit if not penalized or penalty handled
+                if st.session_state.current_player and st.session_state.question and not (penalized_player and penalized_player == st.session_state.current_player) :
+                    if st.button("✅ Submit Answer", key="answer_submit_btn"):
+                        if st.session_state.timer_start: # Check if timer was actually running
+                            time_taken = int(time.time() - st.session_state.timer_start)
+                            points_earned = max(50 - time_taken, 10) # Min 10 points
+                        else: # Should not happen if button is visible, but safeguard
+                            points_earned = 10
+                            st.warning("Timer was not active, default points awarded.")
+
+                        st.session_state.points[st.session_state.current_player] += points_earned
+                        
+                        player_team = st.session_state.players[st.session_state.current_player]['team']
+                        # Add points to actual multi-player teams
+                        if player_team in st.session_state.teams: # st.session_state.teams stores names of multi-player teams
+                            st.session_state.team_points[player_team] = st.session_state.team_points.get(player_team, 0) + points_earned
+                        
+                        st.success(f"🎉 Answer accepted, {st.session_state.current_player}! +{points_earned} points")
+                        st.session_state.current_player = None
+                        st.session_state.question = None
+                        st.session_state.timer_start = None
+                        st.rerun()
+
+        # Suggest a New Question (always visible in game zone if players are registered)
         with st.expander("💡 Suggest a New Question"):
-            with st.form("question_suggestion"):
-                new_category = st.selectbox("Category", list(st.session_state.questions.keys()))
-                new_question = st.text_input("Your Question")
-                if st.form_submit_button("Suggest"):
-                    if player_name:
-                        st.session_state.suggestions.append((new_category, new_question))
-                        st.session_state.points[player_name] += 15
-                        st.success("Question submitted! +15 points")
+            with st.form("question_suggestion_form"):
+                sugg_player_name = st.selectbox("Suggesting as:", get_registered_player_names(), key="sugg_player", help="Select your player name.")
+                sugg_new_category = st.selectbox("Category", list(st.session_state.questions.keys()), key="sugg_cat")
+                sugg_new_question = st.text_input("Your Question Suggestion", key="sugg_q_text")
+                if st.form_submit_button("Suggest Question"):
+                    if sugg_player_name and sugg_new_question and sugg_new_category:
+                        st.session_state.suggestions.append({'player': sugg_player_name, 'category': sugg_new_category, 'question': sugg_new_question, 'time': datetime.now()})
+                        st.session_state.points[sugg_player_name] = st.session_state.points.get(sugg_player_name, 0) + 15
+                        st.success(f"Question suggestion submitted by {sugg_player_name}! +15 points")
+                        st.rerun()
                     else:
-                        st.error("Please register first!")
+                        st.error("Please select your name, category, and write a question to suggest.")
+    else:
+        st.info("👋 Welcome to Gamuu! Please register players in the sidebar to start the game.")
+
 
-with tab2:
+with tab2: # Leaderboard
     st.header("🏅 Player Leaderboard")
-    sorted_players = sorted(st.session_state.points.items(), key=lambda x: x[1], reverse=True)
-    for i, (player, points) in enumerate(sorted_players):
-        avatar = st.session_state.players[player]['avatar']
-        if avatar:
-            st.image(f"data:image/png;base64,{avatar}", width=50)
-        st.metric(f"🥇 {i+1}. {player}", f"{points} points")
-
-    st.header("🏅 Team Leaderboard")
-    sorted_teams = sorted(st.session_state.team_points.items(), key=lambda x: x[1], reverse=True)
-    for i, (team, points) in enumerate(sorted_teams):
-        st.metric(f"🥇 {i+1}. Team {team}", f"{points} points")
-
-    st.header("🏅 Leaderboard History")
-    if st.button("Save Current Leaderboard"):
-        history_entry = {
-            'date': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            'players': dict(sorted_players),
-            'teams': dict(sorted_teams)
-        }
-        st.session_state.leaderboard_history.append(history_entry)
-        st.success("Leaderboard saved!")
-    for entry in st.session_state.leaderboard_history:
-        st.write(f"**{entry['date']}**")
-        st.write("Players:", entry['players'])
-        st.write("Teams:", entry['teams'])
-
-with tab3:
+    if st.session_state.points:
+        sorted_players_points = sorted(st.session_state.points.items(), key=lambda x: x[1], reverse=True)
+        for i, (p_name, p_points) in enumerate(sorted_players_points):
+            player_data = st.session_state.players.get(p_name)
+            cols = st.columns([1,4])
+            with cols[0]:
+                if player_data and player_data.get('avatar'):
+                    try:
+                        st.image(f"data:image/png;base64,{player_data['avatar']}", width=50)
+                    except: pass # Ignore avatar display error
+            with cols[1]:
+                st.metric(f"{'🥇' if i==0 else '🥈' if i==1 else '🥉' if i==2 else f'{i+1}.'} {p_name}", f"{p_points} points")
+    else:
+        st.info("No player points recorded yet.")
+
+    st.header("🏅 Team Leaderboard (Multi-player Teams)")
+    if st.session_state.team_points: # Only show if there are actual multi-player teams with points
+        # Filter for actual teams, not solo players who are their own "team" unless explicitly handled
+        actual_teams_points = {team_name: pts for team_name, pts in st.session_state.team_points.items() if team_name in st.session_state.teams}
+        if actual_teams_points:
+            sorted_teams_display = sorted(actual_teams_points.items(), key=lambda x: x[1], reverse=True)
+            for i, (t_name, t_points) in enumerate(sorted_teams_display):
+                st.metric(f"{'🥇' if i==0 else '🥈' if i==1 else '🥉' if i==2 else f'{i+1}.'} Team {t_name}", f"{t_points} points")
+        else:
+            st.info("No multi-player team points recorded yet.")
+    else:
+        st.info("No team points recorded yet.")
+
+
+    st.header("📜 Leaderboard History")
+    if st.button("Save Current Leaderboard to History", key="save_leaderboard_btn"):
+        if st.session_state.points or st.session_state.team_points:
+            history_entry = {
+                'date': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                'players': dict(st.session_state.points), # Save a copy
+                'teams': dict(st.session_state.team_points) # Save a copy
+            }
+            st.session_state.leaderboard_history.append(history_entry)
+            st.success("Leaderboard snapshot saved!")
+        else:
+            st.warning("Nothing to save (no points recorded).")
+
+    if st.session_state.leaderboard_history:
+        for entry in reversed(st.session_state.leaderboard_history): # Show newest first
+            with st.expander(f"Snapshot from: {entry['date']}"):
+                st.write("**Players:**", entry['players'])
+                st.write("**Teams:**", entry['teams'])
+    else:
+        st.info("No leaderboard history saved yet.")
+
+
+with tab3: # Redeem Points
     st.header("🛍️ Redeem Points")
-    if player_name and player_name in st.session_state.points:
-        current_points = st.session_state.points[player_name]
-        st.write(f"Your available points: {current_points}")
+    redeeming_player = st.selectbox("Select Player for Redemption:", get_registered_player_names(), key="redeem_player_select", help="Choose who is redeeming points.")
+    
+    if redeeming_player:
+        current_player_points = st.session_state.points.get(redeeming_player, 0)
+        st.write(f"**{redeeming_player}** has **{current_player_points}** points available.")
+
+        rewards = {
+            "Basic": [("Custom Emoji 🎨", 50, "emoji_reward"), ("Nickname Color Change 🌈", 75, "color_reward")],
+            "Premium": [("Special Badge ✨", 200, "badge_reward"), ("Unlock 'Dare Devil' Mode (more dares) 😈", 250, "dare_mode_reward")],
+            "Spicy": [("18+ Question Pack 🔥", 300, "spicy_pack_reward"), ("'Ultimate Truth' Question for someone else 💣", 400, "ultimate_truth_reward")]
+        }
 
-        col1, col2, col3 = st.columns(3)
-        with col1:
-            st.subheader("🎁 Basic Rewards")
-            if st.button("Custom Emoji (50 points)"):
-                if current_points >= 50:
-                    st.session_state.points[player_name] -= 50
-                    st.success("🎉 Emoji unlocked!")
-        with col2:
-            st.subheader("💎 Premium Rewards")
-            if st.button("Special Badge (200 points)"):
-                if current_points >= 200:
-                    st.session_state.points[player_name] -= 200
-                    st.success("🌟 Badge awarded!")
-        with col3:
-            st.subheader("🔥 Spicy Rewards")
-            if st.button("18+ Question Pack (300 points)"):
-                if current_points >= 300:
-                    st.session_state.points[player_name] -= 300
-                    st.success("🔞 Pack unlocked!")
+        cols = st.columns(len(rewards))
+        for i, (tier_name, tier_rewards) in enumerate(rewards.items()):
+            with cols[i]:
+                st.subheader(f"🎁 {tier_name} Rewards")
+                for reward_name, cost, reward_key_suffix in tier_rewards:
+                    if st.button(f"{reward_name} ({cost} points)", key=f"redeem_{reward_key_suffix}_{redeeming_player}", disabled=current_player_points < cost):
+                        if current_player_points >= cost:
+                            st.session_state.points[redeeming_player] -= cost
+                            # Add achievement logic or actual reward effect here
+                            if redeeming_player not in st.session_state.achievements:
+                                st.session_state.achievements[redeeming_player] = []
+                            achievement_text = f"Redeemed '{reward_name}'"
+                            if achievement_text not in st.session_state.achievements[redeeming_player]:
+                                 st.session_state.achievements[redeeming_player].append(achievement_text)
+                            st.success(f"🎉 {reward_name} redeemed by {redeeming_player}!")
+                            st.rerun() # Update points display and button states
+                        # else: # Button should be disabled, but as a fallback
+                        #     st.error("Not enough points! (Button should have been disabled)")
     else:
-        st.warning("Please register to redeem points.")
+        st.info("Please register players and select a player to see redeemable rewards.")
 
-with tab4:
+with tab4: # Achievements
     st.header("🌟 Achievements")
-    if player_name:
-        st.write(f"🏆 {player_name}'s Achievements:")
-        if st.session_state.achievements.get(player_name):
-            for achievement in st.session_state.achievements[player_name]:
-                st.write(f"- {achievement}")
+    achievements_player = st.selectbox("View Achievements For:", get_registered_player_names(), key="achievements_player_select", help="Select player to view their achievements.")
+
+    if achievements_player:
+        st.write(f"🏆 **{achievements_player}'s Achievements:**")
+        player_achievements = st.session_state.achievements.get(achievements_player, [])
+        if player_achievements:
+            for ach in player_achievements:
+                st.markdown(f"- {ach}")
         else:
-            st.write("No achievements yet. Keep playing!")
+            st.write("No achievements unlocked yet. Keep playing to earn them!")
     else:
-        st.warning("Please register to view achievements.")
+        st.info("Please register players and select a player to view achievements.")
 
-# Footer
+# --- Footer ---
 st.markdown("---")
-st.markdown("**🎮 Gamuu** - Where Connections Get Interesting! ⋅ v3.0 ⋅ [Privacy Policy] ⋅ [Terms of Service]")
+st.markdown("Made with ❤️ for **Gamuu** - v3.1 ⋅ [Privacy Policy] ⋅ [Terms of Service]")
+st.caption("Note: 'Ultimate Truth' and 'Dare Devil Mode' are conceptual and not fully implemented in game logic yet.")