new tracker

app.py

@@ -5,6 +5,7 @@ st.set_page_config(page_title="Board Game Tracker", layout="wide")
 home_page = st.Page("pages/home.py", title="Home", url_path="home", default=True)
 skull_king_page = st.Page("pages/skull_king.py", title="Skull King", url_path="skull_king")
 dungeon_draft_page = st.Page("pages/dungeon_draft.py", title="Dungeon Draft", url_path="dungeon_draft")
+points_tracker_page = st.Page("pages/points_tracker.py", title="Points Tracker", url_path="points_tracker")
 
-pg = st.navigation([home_page, skull_king_page, dungeon_draft_page])
+pg = st.navigation([home_page, skull_king_page, dungeon_draft_page, points_tracker_page])
 pg.run()

pages/home.py

@@ -17,6 +17,7 @@ no data collection. Your game data lives in your browser session only.
 |------|-------------|
 | **Skull King** | A trick-taking pirate card game for 2-6 players. Track bids and scores across up to 10 rounds. |
 | **Dungeon Draft** | A dungeon-crawling card drafting game. Track money, damage, and victory points with full transaction support. |
+| **Points Tracker** | Universal tracker for any points-based game. Set a winning score, enter round-by-round points, and view a cumulative progression chart. |
 
 ---
 

pages/points_tracker.py

@@ -0,0 +1,204 @@
+import streamlit as st
+import pandas as pd
+import altair as alt
+
+
+def _init_state():
+    if "pt_players" not in st.session_state:
+        st.session_state.pt_players = []
+    if "pt_game_started" not in st.session_state:
+        st.session_state.pt_game_started = False
+    if "pt_scores" not in st.session_state:
+        st.session_state.pt_scores = []
+    if "pt_winning_score" not in st.session_state:
+        st.session_state.pt_winning_score = 100
+    if "pt_game_name" not in st.session_state:
+        st.session_state.pt_game_name = ""
+
+
+def _setup_phase():
+    st.subheader("Game Setup")
+
+    st.session_state.pt_game_name = st.text_input(
+        "Game name (optional)",
+        value=st.session_state.pt_game_name,
+        placeholder="e.g. Catan, Ticket to Ride…",
+    )
+
+    st.session_state.pt_winning_score = st.number_input(
+        "Winning score (points to win)",
+        min_value=1,
+        value=st.session_state.pt_winning_score,
+        step=10,
+    )
+
+    st.subheader("Players")
+
+    def _add_player():
+        name = st.session_state.pt_new_player.strip()
+        if name and name not in st.session_state.pt_players:
+            st.session_state.pt_players.append(name)
+        st.session_state.pt_new_player = ""
+
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        st.text_input("Player name", key="pt_new_player")
+    with col2:
+        st.write("")
+        st.write("")
+        st.button("Add Player", key="pt_add_btn", on_click=_add_player)
+
+    if st.session_state.pt_players:
+        st.markdown("**Players:**")
+        for i, p in enumerate(st.session_state.pt_players):
+            col_name, col_del = st.columns([4, 1])
+            col_name.write(f"{i + 1}. {p}")
+            if col_del.button("Remove", key=f"pt_rm_{i}"):
+                st.session_state.pt_players.pop(i)
+                st.rerun()
+
+        if len(st.session_state.pt_players) >= 2:
+            if st.button("Start Game", type="primary"):
+                st.session_state.pt_game_started = True
+                st.session_state.pt_scores = []
+                st.rerun()
+    else:
+        st.info("Add at least 2 players to start.")
+
+
+def _compute_cumulative(players, scores):
+    cumsum = {p: 0 for p in players}
+    history = []
+    for round_data in scores:
+        for p in players:
+            cumsum[p] += round_data.get(p, 0)
+        history.append(dict(cumsum))
+    return cumsum, history
+
+
+def _render_scoreboard(players, scores, winning_score):
+    cumsum = {p: 0 for p in players}
+
+    header_cols = ["Round"] + players
+    md = "| " + " | ".join(header_cols) + " |\n"
+    md += "| " + " | ".join(["---"] * len(header_cols)) + " |\n"
+
+    for i, round_data in enumerate(scores):
+        row = [f"**{i + 1}**"]
+        for p in players:
+            pts = round_data.get(p, 0)
+            prev = cumsum[p]
+            cumsum[p] += pts
+            change = cumsum[p] - prev
+            if change > 0:
+                indicator = f' <span style="color:green">&#9650; +{change}</span>'
+            elif change < 0:
+                indicator = f' <span style="color:red">&#9660; {change}</span>'
+            else:
+                indicator = ""
+            winner_flag = " ★" if cumsum[p] >= winning_score else ""
+            row.append(f"**{cumsum[p]}**{indicator}{winner_flag}")
+        md += "| " + " | ".join(row) + " |\n"
+
+    st.markdown(md, unsafe_allow_html=True)
+
+
+def _render_chart(players, scores):
+    if not scores:
+        return
+
+    cumsum = {p: 0 for p in players}
+    rows = [{"Round": 0, **{p: 0 for p in players}}]
+    for i, round_data in enumerate(scores):
+        for p in players:
+            cumsum[p] += round_data.get(p, 0)
+        rows.append({"Round": i + 1, **dict(cumsum)})
+
+    df = pd.DataFrame(rows)
+    df_long = df.melt(id_vars="Round", var_name="Player", value_name="Points")
+
+    chart = (
+        alt.Chart(df_long)
+        .mark_line(point=True)
+        .encode(
+            x=alt.X("Round:Q", axis=alt.Axis(tickMinStep=1)),
+            y=alt.Y("Points:Q"),
+            color=alt.Color("Player:N"),
+            tooltip=["Round", "Player", "Points"],
+        )
+        .properties(height=300)
+        .interactive()
+    )
+
+    st.altair_chart(chart, use_container_width=True)
+
+
+def _game_phase():
+    players = st.session_state.pt_players
+    scores = st.session_state.pt_scores
+    winning_score = st.session_state.pt_winning_score
+    game_name = st.session_state.pt_game_name
+
+    if game_name:
+        st.subheader(f"Tracking: {game_name}")
+
+    col_reset, col_undo = st.columns([1, 1])
+    with col_reset:
+        if st.button("Reset Game"):
+            st.session_state.pt_game_started = False
+            st.session_state.pt_players = []
+            st.session_state.pt_scores = []
+            st.rerun()
+    with col_undo:
+        if scores and st.button("Undo Last Round"):
+            st.session_state.pt_scores.pop()
+            st.rerun()
+
+    cumsum, _ = _compute_cumulative(players, scores)
+    winners = [p for p in players if cumsum[p] >= winning_score]
+
+    if scores:
+        st.subheader("Scoreboard")
+        _render_scoreboard(players, scores, winning_score)
+
+        with st.expander("Points progression chart", expanded=False):
+            _render_chart(players, scores)
+
+    if winners:
+        st.success(f"Game over! Winner{'s' if len(winners) > 1 else ''}: **{', '.join(winners)}** reached {winning_score} points!")
+        st.subheader("Final Standings")
+        ranked = sorted(cumsum.items(), key=lambda x: x[1], reverse=True)
+        for i, (player, total) in enumerate(ranked):
+            medal = ["1st", "2nd", "3rd"][i] if i < 3 else f"{i + 1}th"
+            st.write(f"**{medal}** - {player}: **{total}** points")
+        return
+
+    next_round = len(scores) + 1
+    st.subheader(f"Round {next_round}")
+    st.caption(f"Target: {winning_score} points to win.")
+
+    round_scores = {}
+    cols = st.columns(len(players))
+    for i, player in enumerate(players):
+        with cols[i]:
+            current = cumsum[player]
+            round_scores[player] = st.number_input(
+                f"{player} ({current} pts)",
+                value=0,
+                step=1,
+                key=f"pt_input_r{next_round}_{player}",
+            )
+
+    if st.button("Save Round", type="primary", key=f"pt_save_r{next_round}"):
+        st.session_state.pt_scores.append(round_scores)
+        st.rerun()
+
+
+# Page entry point
+st.title("Points Tracker")
+_init_state()
+
+if not st.session_state.pt_game_started:
+    _setup_phase()
+else:
+    _game_phase()