Update app.py

app.py

@@ -400,21 +400,23 @@ def unified_push_message(game_id, msg_obj):
 # ---------------------------
 def unified_push_leaderboard(row):
     """
-    Push a row to leaderboard (Firebase if Online, CSV if Offline) 
-    and automatically adds a UTC timestamp.
+    Push a row to leaderboard per game_id in Firebase and also local CSV.
     """
-    row = row.copy()  # avoid mutating input
-    # Add UTC timestamp
-    row["timestamp"] = datetime.utcnow().isoformat() + "Z"  # e.g., 2026-01-03T17:30:00Z
+    row = row.copy()
+    row["timestamp"] = datetime.utcnow().isoformat() + "Z"
+    game_id = row.get("game_id")
+    username = row.get("name")
 
     mode = st.session_state.get("mode_selection", "Offline")
     
     if mode == "Online":
         ok, _ = init_firebase_if_needed()
-        if ok:
-            fb_push("/leaderboard", row)
+        if ok and game_id and username:
+            # Push under game_id
+            ref = db.reference(f"/games/{game_id}/scores/{username}")
+            ref.set(row)
     
-    # Always save local CSV backup
+    # Local CSV backup
     try:
         df = pd.read_csv(LEADERBOARD_FILE)
     except FileNotFoundError:
@@ -423,6 +425,30 @@ def unified_push_leaderboard(row):
     df = pd.concat([df, pd.DataFrame([row])], ignore_index=True)
     df.to_csv(LEADERBOARD_FILE, index=False)
 
+def show_game_leaderboard(game_id):
+    st.subheader(f"Leaderboard for Game {game_id}")
+
+    mode = st.session_state.get("mode_selection", "Offline")
+
+    rows = []
+    if mode == "Online":
+        ok, _ = init_firebase_if_needed()
+        if ok:
+            rows_dict = fb_get(f"/games/{game_id}/scores") or {}
+            rows = list(rows_dict.values())
+    else:
+        df = pd.read_csv(LEADERBOARD_FILE)
+        rows = df[df["game_id"]==game_id].to_dict(orient="records")
+
+    if not rows:
+        st.info("No scores yet for this game.")
+        return
+
+    rows.sort(key=lambda x: x.get("score",0), reverse=True)
+
+    for i, r in enumerate(rows, 1):
+        st.write(f"{i}. {r.get('avatar','🎮')} **{r['name']}** — {r.get('score')} pts")
+
 # ---------------------------
 # Get weekly leaderboard
 # ---------------------------
@@ -828,86 +854,82 @@ def get_top3_and_player_count(game_id):
 # Home page
 
 HEARTBEAT_THRESHOLD_SECONDS = 60  # adjust if needed
-
 def home_page():
     st.header("Home")
     st.write("Create games, invite friends, play and climb the leaderboard.")
 
     # ---------------- TOTAL ONLINE PLAYERS ----------------
-    players_map = unified_get("players") or {}
-    total_online = sum(len(v) for v in players_map.values())
+    total_online = get_total_online_players()
     st.metric("🟢 Players Online", total_online)
 
     # ---------------- SHOW LAST SCORE ----------------
     last_score = st.session_state.get('last_score')
     last_game = st.session_state.get('last_game')
-    if last_score is not None:
+    if last_score is not None and last_game:
         st.success(f"Your last score: {last_score} (Game {last_game})")
 
     # ---------------- LOAD GAMES ----------------
     games = unified_get("games") or {}
-    st.subheader("Recent games")
+    if not games:
+        st.info("No games exist yet. Please create a game first.")
+        return
 
+    st.subheader("Recent Games")
     for g in sorted(games.values(), key=lambda x: x.get("created_at", ""), reverse=True)[:10]:
         gid = g.get("game_id")
-
-        # Use players/submissions stored in game dict
-        players = g.get("players", [])
-        submissions = g.get("submissions", {})
-
         st.markdown(f"### 🎮 Game: **{gid}** {'(Closed)' if g.get('closed') else ''}")
         st.write(f"Host: {g.get('host')} — Topics: {', '.join(g.get('topics', []))}")
         st.write(f"Created: {g.get('created_at')}")
 
-        joined = len(players)
-        submitted = len(submissions)
+        # Players & submissions
+        players = g.get("players", [])
+        submissions = g.get("submissions", {})
 
-        st.write(f"Players joined: **{joined}**")
-        st.write(f"Submitted: **{submitted} / {joined}**")
+        st.write(f"Players joined: **{len(players)}**")
+        st.write(f"Submitted: **{len(submissions)} / {len(players)}**")
 
-        # ---------------- TOP 3 PLAYERS ----------------
+        # Top 3 players
         if submissions:
             st.markdown("🏆 **Top 3 Players**")
             top_players = sorted(submissions.items(), key=lambda x: x[1], reverse=True)[:3]
-            for i, (uname_p, score) in enumerate(top_players, start=1):
-                st.write(f"{i}. 🎮 **{uname_p}** — {score} pts")
+            for i, (uname, score) in enumerate(top_players, start=1):
+                st.write(f"{i}. 🎮 **{uname}** — {score} pts")
 
-        # ---------------- PLAYER STATUS ----------------
+        # Player status
         if players:
             st.markdown("**👥 Player Status**")
-            for uname_p in players:
-                if uname_p in submissions:
-                    st.write(f"🎮 **{uname_p}** — ✅ Submitted ({submissions[uname_p]} pts)")
+            for uname in players:
+                if uname in submissions:
+                    st.write(f"🎮 **{uname}** — ✅ Submitted ({submissions[uname]} pts)")
                 else:
-                    st.write(f"🎮 **{uname_p}** — ⏳ Playing")
+                    st.write(f"🎮 **{uname}** — ⏳ Playing")
 
         st.markdown("---")
 
-        # ---------------- INVITE & CHALLENGE ----------------
-        if not g.get("closed"):
+        # Invite & challenge friends
+        if not g.get("closed") and st.session_state.get("username"):
             st.info(f"Share this Game ID: {gid}")
             render_copy_button(gid, gid)
 
-            if st.session_state.get("username"):
-                if st.button(f"Invite your friends to {gid}", key=f"invite_{gid}"):
-                    friends = get_friends_map().get(st.session_state["username"], [])
-                    if not friends:
-                        st.warning("No friends to invite.")
-                    else:
-                        for f in friends:
-                            send_game_invite(st.session_state["username"], f, gid)
-                        st.success("Invites sent to friends.")
-
-                if st.button(f"Challenge friends with a new game like {gid}", key=f"challenge_{gid}"):
-                    new_id = create_game(
-                        st.session_state.get("username", "Host"),
-                        g.get("topics", []),
-                        num_questions=len(g.get("questions", []))
-                    )
-                    st.session_state["active_game_id"] = new_id
-                    st.session_state["game_questions"] = games.get(new_id, {}).get("questions", [])
-                    st.success(f"Challenge created: {new_id}")
-                    st.experimental_rerun()
+            if st.button(f"Invite friends to {gid}", key=f"invite_{gid}"):
+                friends = get_friends_map().get(st.session_state["username"], [])
+                if not friends:
+                    st.warning("No friends to invite.")
+                else:
+                    for f in friends:
+                        send_game_invite(st.session_state["username"], f, gid)
+                    st.success("Invites sent to friends.")
+
+            if st.button(f"Challenge friends with a new game like {gid}", key=f"challenge_{gid}"):
+                new_id = create_game(
+                    host=st.session_state.get("username", "Host"),
+                    topics=g.get("topics", []),
+                    num_questions=len(g.get("questions", []))
+                )
+                st.success(f"Challenge created: {new_id}")
+                st.session_state['active_game_id'] = new_id
+                st.session_state['game_questions'] = games.get(new_id, {}).get("questions", [])
+                st.experimental_rerun()
 
     # ---------------- WEEKLY LEADERBOARD ----------------
     st.subheader("🏆 Weekly Leaderboard (Top 10)")
@@ -918,87 +940,25 @@ def home_page():
         for i, r in enumerate(weekly, 1):
             st.write(f"{i}. {r.get('avatar','🎮')} **{r['name']}** (Game {r['game_id']}) — {r['score']} pts")
 
-    # ---------------- PLAY PAGE SETUP ----------------
-    if 'active_game' not in st.session_state:
-        if games:
-            st.session_state['active_game'] = list(games.keys())[0]
-        else:
-            st.warning("No games exist yet. Please create a game first.")
-
-    if 'username' not in st.session_state:
-        st.session_state['username'] = "Guest"
-
-    # Safely update player submissions if a game is active
+    # ---------------- UPDATE ACTIVE GAME SUBMISSIONS ----------------
     active_game_id = st.session_state.get('active_game')
-    if active_game_id and 'final_score' in st.session_state:
-        game = unified_get(f"games/{active_game_id}") or {}
-        players = game.get("players", [])
-        username = st.session_state['username']
-
-        if username not in players:
-            players.append(username)
+    username = st.session_state.get('username')
+    if active_game_id and 'final_score' in st.session_state and username:
+        games = unified_get("games") or {}
+        game = games.get(active_game_id, {})
+        if game:
+            players = game.get("players", [])
+            submissions = game.get("submissions", {})
 
-        submissions = game.get("submissions", {})
-        submissions[username] = st.session_state['final_score']
+            if username not in players:
+                players.append(username)
+            submissions[username] = st.session_state['final_score']
 
-        game["players"] = players
-        game["submissions"] = submissions
-        unified_set(f"games/{active_game_id}", game)
+            game["players"] = players
+            game["submissions"] = submissions
+            unified_set("games", {active_game_id: game})
 
-def create_game(host=None, topics=[], num_questions=5, auto_close=True, ai_topic=None):
-    games = unified_get("games") or {}
-    gid = f"GAME{int(time.time())}"
-    host = host or st.session_state.get("username", "Host")
-
-    questions = []
-
-    # 1️⃣ AI questions (already dict format)
-    if ai_topic:
-        ai_questions = generate_ai_questions(ai_topic, num_questions=num_questions)
-        if ai_questions:
-            for q in ai_questions:
-                questions.append({
-                    "question": q.get("question", ""),
-                    "options": q.get("options", []),
-                    "answer": q.get("answer", "")
-                })
 
-    # 2️⃣ Static fallback (tuple → dict conversion)
-    if not questions:
-        for topic in topics:
-            qs = questions_db.get(topic, [])
-            for q in qs[:num_questions]:
-                questions.append({
-                    "question": q[0],
-                    "options": q[1],
-                    "answer": q[2]
-                })
-
-    # 🔹 Store game
-    games[gid] = {
-        "game_id": gid,
-        "host": host,
-        "topics": topics,
-        "questions": questions,
-        "created_at": now_iso(),
-        "closed": False,
-        "auto_close": auto_close
-    }
-
-    unified_set("games", games)
-
-    # ✅ REQUIRED: prepare play state
-    st.session_state['game_id'] = gid
-    st.session_state['active_game_id'] = gid
-    st.session_state['game_questions'] = questions
-    st.session_state['current_index'] = 0
-    st.session_state['answers'] = [""] * len(questions)
-    st.session_state['answer_times'] = [None] * len(questions)
-    st.session_state['question_started_at'] = None
-
-    st.success(f"Game created: {gid} with {len(questions)} questions.")
-    return gid
-    
 # -------------------------
 # PLAY PAGE
 # -------------------------