Upload 4 files

app.py

@@ -0,0 +1,10 @@
+import streamlit as st
+
+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")
+
+pg = st.navigation([home_page, skull_king_page, dungeon_draft_page])
+pg.run()

pages/dungeon_draft.py

@@ -0,0 +1,338 @@
+import streamlit as st
+import copy
+
+
+def _init_state():
+    if "dd_players" not in st.session_state:
+        st.session_state.dd_players = []
+    if "dd_game_started" not in st.session_state:
+        st.session_state.dd_game_started = False
+    if "dd_track_damage" not in st.session_state:
+        st.session_state.dd_track_damage = False
+    # dd_rounds[round_idx] = {player: {"money": int, "damage": int, "vp": int}}
+    # round 0 = starting balance
+    if "dd_rounds" not in st.session_state:
+        st.session_state.dd_rounds = {}
+    # dd_pending[player] = {"money": int, "damage": int, "vp": int}
+    if "dd_pending" not in st.session_state:
+        st.session_state.dd_pending = {}
+    if "dd_finished" not in st.session_state:
+        st.session_state.dd_finished = set()
+    if "dd_current_round" not in st.session_state:
+        st.session_state.dd_current_round = 1
+    # Gold income per player applied AFTER each round is committed
+    if "dd_gold_income" not in st.session_state:
+        st.session_state.dd_gold_income = {}
+    # Starting balance per player (set during setup)
+    if "dd_starting_balance" not in st.session_state:
+        st.session_state.dd_starting_balance = {}
+
+
+def _reset_pending():
+    st.session_state.dd_pending = {
+        p: {"money": 0, "damage": 0, "vp": 0}
+        for p in st.session_state.dd_players
+    }
+    st.session_state.dd_finished = set()
+
+
+def _setup_phase():
+    st.subheader("Game Setup")
+
+    st.session_state.dd_track_damage = st.checkbox(
+        "Track damage per round (optional)", value=st.session_state.dd_track_damage
+    )
+
+    st.markdown("---")
+    st.subheader("Players")
+
+    def _dd_add_player():
+        name = st.session_state.dd_new_player.strip()
+        if name and name not in st.session_state.dd_players:
+            st.session_state.dd_players.append(name)
+            st.session_state.dd_gold_income[name] = 5
+            st.session_state.dd_starting_balance[name] = 9
+        st.session_state.dd_new_player = ""
+
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        st.text_input("Player name", key="dd_new_player")
+    with col2:
+        st.write("")
+        st.write("")
+        st.button("Add Player", key="dd_add_btn", on_click=_dd_add_player)
+
+    if st.session_state.dd_players:
+        for i, p in enumerate(st.session_state.dd_players):
+            col_name, col_del = st.columns([4, 1])
+            col_name.write(f"{i + 1}. {p}")
+            if col_del.button("Remove", key=f"dd_rm_{i}"):
+                st.session_state.dd_players.pop(i)
+                st.session_state.dd_gold_income.pop(p, None)
+                st.session_state.dd_starting_balance.pop(p, None)
+                st.rerun()
+
+        st.markdown("---")
+        st.subheader("Starting Balance & Gold Income")
+        for p in st.session_state.dd_players:
+            col_bal, col_inc = st.columns(2)
+            with col_bal:
+                st.session_state.dd_starting_balance[p] = st.number_input(
+                    f"{p} - Starting Gold",
+                    value=st.session_state.dd_starting_balance.get(p, 0),
+                    step=1,
+                    min_value=0,
+                    key=f"dd_setup_bal_{p}",
+                )
+            with col_inc:
+                st.session_state.dd_gold_income[p] = st.number_input(
+                    f"{p} - Gold Income per Round",
+                    value=st.session_state.dd_gold_income.get(p, 0),
+                    step=1,
+                    min_value=0,
+                    key=f"dd_setup_inc_{p}",
+                )
+
+        if len(st.session_state.dd_players) >= 2:
+            if st.button("Start Game", type="primary"):
+                st.session_state.dd_game_started = True
+                # Round 0 = starting balance
+                st.session_state.dd_rounds = {
+                    0: {
+                        p: {
+                            "money": st.session_state.dd_starting_balance.get(p, 0),
+                            "damage": 0,
+                            "vp": 0,
+                        }
+                        for p in st.session_state.dd_players
+                    }
+                }
+                st.session_state.dd_current_round = 1
+                _reset_pending()
+                st.rerun()
+    else:
+        st.info("Add at least 2 players to start.")
+
+
+def _game_phase():
+    players = st.session_state.dd_players
+    rounds = st.session_state.dd_rounds
+    current_round = st.session_state.dd_current_round
+    track_damage = st.session_state.dd_track_damage
+
+    if st.button("Reset Game"):
+        st.session_state.dd_game_started = False
+        st.session_state.dd_players = []
+        st.session_state.dd_rounds = {}
+        st.session_state.dd_pending = {}
+        st.session_state.dd_finished = set()
+        st.session_state.dd_current_round = 1
+        st.session_state.dd_gold_income = {}
+        st.session_state.dd_starting_balance = {}
+        st.rerun()
+
+    # Gold income settings in sidebar (adjustable during game)
+    with st.sidebar:
+        st.markdown("---")
+        st.subheader("Gold Income per Round")
+        st.caption("Applied after each round is committed.")
+        for p in players:
+            st.session_state.dd_gold_income[p] = st.number_input(
+                f"{p}",
+                value=st.session_state.dd_gold_income.get(p, 0),
+                step=1,
+                min_value=0,
+                key=f"dd_income_{p}",
+            )
+
+    # Scoreboard (always visible since round 0 exists)
+    completed_rounds = sorted(rounds.keys())
+    st.subheader("Scoreboard")
+    _render_scoreboard(players, rounds, completed_rounds, track_damage)
+
+    # Current round
+    st.subheader(f"Round {current_round}")
+    st.caption(
+        "Add/reduce values for each player. Changes are staged until you finish the player's turn. "
+        "Use the Pirate Card section to steal from other players."
+    )
+
+    pending = st.session_state.dd_pending
+    finished = st.session_state.dd_finished
+
+    tabs = st.tabs(players)
+    for idx, player in enumerate(players):
+        with tabs[idx]:
+            is_finished = player in finished
+
+            if is_finished:
+                st.success(f"{player}'s turn is finished for this round.")
+                st.write(f"Money: **{pending[player]['money']:+d}**")
+                if track_damage:
+                    st.write(f"Damage: **{pending[player]['damage']:+d}**")
+                st.write(f"Victory Points: **{pending[player]['vp']:+d}**")
+                continue
+
+            st.markdown(f"**{player}'s Turn**")
+
+            # Show current cumulative balance
+            cum = _get_cumulative(player, rounds, completed_rounds)
+            bal_parts = [f"Money: **{cum['money']}**", f"VP: **{cum['vp']}**"]
+            if track_damage:
+                bal_parts.append(f"Damage: **{cum['damage']}**")
+            st.caption("Current balance: " + " | ".join(bal_parts))
+
+            col_money, col_vp = st.columns(2)
+            with col_money:
+                money_change = st.number_input(
+                    "Money +/-",
+                    value=0,
+                    step=1,
+                    key=f"dd_money_{current_round}_{player}",
+                )
+            with col_vp:
+                vp_change = st.number_input(
+                    "Victory Points +/-",
+                    value=0,
+                    step=1,
+                    key=f"dd_vp_{current_round}_{player}",
+                )
+
+            damage_change = 0
+            if track_damage:
+                damage_change = st.number_input(
+                    "Damage +/-",
+                    value=0,
+                    step=1,
+                    key=f"dd_dmg_{current_round}_{player}",
+                )
+
+            if st.button("Stage Changes", key=f"dd_stage_{current_round}_{player}"):
+                pending[player]["money"] += money_change
+                pending[player]["vp"] += vp_change
+                if track_damage:
+                    pending[player]["damage"] += damage_change
+                st.rerun()
+
+            if any(v != 0 for v in pending[player].values()):
+                st.markdown("**Staged changes:**")
+                st.write(f"Money: {pending[player]['money']:+d}")
+                if track_damage:
+                    st.write(f"Damage: {pending[player]['damage']:+d}")
+                st.write(f"VP: {pending[player]['vp']:+d}")
+
+            # Pirate card
+            st.markdown("---")
+            show_pirate = st.checkbox(
+                "Pirate Card - Steal", key=f"dd_pirate_show_{current_round}_{player}"
+            )
+            other_players = [p for p in players if p != player]
+            if show_pirate and other_players:
+                steal_target = st.selectbox(
+                    "Steal from",
+                    other_players,
+                    key=f"dd_pirate_target_{current_round}_{player}",
+                )
+                steal_col1, steal_col2 = st.columns(2)
+                with steal_col1:
+                    steal_type = st.selectbox(
+                        "Resource",
+                        ["money", "vp"] + (["damage"] if track_damage else []),
+                        key=f"dd_pirate_type_{current_round}_{player}",
+                    )
+                with steal_col2:
+                    steal_amount = st.number_input(
+                        "Amount to steal",
+                        min_value=0,
+                        value=0,
+                        step=1,
+                        key=f"dd_pirate_amt_{current_round}_{player}",
+                    )
+                if st.button("Steal", key=f"dd_pirate_btn_{current_round}_{player}"):
+                    if steal_amount > 0:
+                        pending[player][steal_type] += steal_amount
+                        pending[steal_target][steal_type] -= steal_amount
+                        st.success(
+                            f"{player} stole {steal_amount} {steal_type} from {steal_target}!"
+                        )
+                        st.rerun()
+
+            st.markdown("---")
+            if st.button(
+                "Finish Turn", type="primary", key=f"dd_finish_{current_round}_{player}"
+            ):
+                st.session_state.dd_finished.add(player)
+                st.rerun()
+
+    # Commit round when all done
+    if len(finished) == len(players):
+        st.markdown("---")
+        st.info("All players have finished their turns.")
+        if st.button("Commit Round", type="primary", key=f"dd_commit_{current_round}"):
+            # Save the round's changes
+            round_data = copy.deepcopy(pending)
+            # Add gold income as a separate entry after the round
+            gold_income = st.session_state.dd_gold_income
+            for p in players:
+                round_data[p]["money"] += gold_income.get(p, 0)
+            st.session_state.dd_rounds[current_round] = round_data
+            st.session_state.dd_current_round += 1
+            _reset_pending()
+            st.rerun()
+
+
+def _get_cumulative(player, rounds, completed_rounds):
+    cum = {"money": 0, "damage": 0, "vp": 0}
+    for r in completed_rounds:
+        for k in cum:
+            cum[k] += rounds[r][player].get(k, 0)
+    return cum
+
+
+def _render_scoreboard(players, rounds, completed_rounds, track_damage):
+    metrics = ["Money", "VP"] + (["Damage"] if track_damage else [])
+    metric_keys = ["money", "vp"] + (["damage"] if track_damage else [])
+
+    header = ["Round"]
+    for p in players:
+        for m in metrics:
+            header.append(f"{p} - {m}")
+
+    cumsum = {p: {k: 0 for k in metric_keys} for p in players}
+    prev_cumsum = {p: {k: 0 for k in metric_keys} for p in players}
+
+    rows = []
+    for r in completed_rounds:
+        label = "Start" if r == 0 else str(r)
+        row = [f"**{label}**"]
+        for p in players:
+            for k in metric_keys:
+                prev_cumsum[p][k] = cumsum[p][k]
+                val = rounds[r][p].get(k, 0)
+                cumsum[p][k] += val
+                change = cumsum[p][k] - prev_cumsum[p][k]
+                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 = ""
+                row.append(f"**{cumsum[p][k]}**{indicator}")
+        rows.append(row)
+
+    md = "| " + " | ".join(header) + " |\n"
+    md += "| " + " | ".join(["---"] * len(header)) + " |\n"
+    for row in rows:
+        md += "| " + " | ".join(str(c) for c in row) + " |\n"
+
+    st.markdown(md, unsafe_allow_html=True)
+
+
+# Page entry point
+st.title("Dungeon Draft")
+_init_state()
+
+if not st.session_state.dd_game_started:
+    _setup_phase()
+else:
+    _game_phase()

pages/home.py

@@ -0,0 +1,30 @@
+import streamlit as st
+
+st.title("Board Game Tracker")
+
+st.markdown(
+    """
+### Free & Open Source
+
+This application is **completely free** and **open source**. No accounts, no subscriptions,
+no data collection. Your game data lives in your browser session only.
+
+---
+
+### Supported Games
+
+| Game | Description |
+|------|-------------|
+| **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. |
+
+---
+
+### How It Works
+
+- Select a game from the **left sidebar** to start tracking.
+- All data persists within your current browser session.
+- Add players, record rounds, and view cumulative scores in real time.
+- Starting a new browser session gives you a fresh slate.
+"""
+)

pages/skull_king.py

@@ -0,0 +1,134 @@
+import streamlit as st
+
+
+def _init_state():
+    if "sk_players" not in st.session_state:
+        st.session_state.sk_players = []
+    if "sk_game_started" not in st.session_state:
+        st.session_state.sk_game_started = False
+    if "sk_scores" not in st.session_state:
+        st.session_state.sk_scores = {}
+
+
+def _setup_phase():
+    st.subheader("Player Setup")
+
+    def _sk_add_player():
+        name = st.session_state.sk_new_player.strip()
+        if name and name not in st.session_state.sk_players:
+            st.session_state.sk_players.append(name)
+        st.session_state.sk_new_player = ""
+
+    col1, col2 = st.columns([3, 1])
+    with col1:
+        st.text_input("Player name", key="sk_new_player")
+    with col2:
+        st.write("")
+        st.write("")
+        st.button("Add Player", key="sk_add_btn", on_click=_sk_add_player)
+
+    if st.session_state.sk_players:
+        st.markdown("**Players:**")
+        for i, p in enumerate(st.session_state.sk_players):
+            col_name, col_del = st.columns([4, 1])
+            col_name.write(f"{i + 1}. {p}")
+            if col_del.button("Remove", key=f"sk_rm_{i}"):
+                st.session_state.sk_players.pop(i)
+                st.rerun()
+
+        if len(st.session_state.sk_players) >= 2:
+            if st.button("Start Game", type="primary"):
+                st.session_state.sk_game_started = True
+                st.session_state.sk_scores = {}
+                st.rerun()
+    else:
+        st.info("Add at least 2 players to start.")
+
+
+def _game_phase():
+    players = st.session_state.sk_players
+    scores = st.session_state.sk_scores
+    completed_rounds = sorted(scores.keys())
+    next_round = (completed_rounds[-1] + 1) if completed_rounds else 1
+
+    if st.button("Reset Game"):
+        st.session_state.sk_game_started = False
+        st.session_state.sk_players = []
+        st.session_state.sk_scores = {}
+        st.rerun()
+
+    if completed_rounds:
+        st.subheader("Scoreboard")
+        _render_scoreboard(players, scores, completed_rounds)
+
+    if next_round <= 10:
+        st.subheader(f"Round {next_round}")
+        st.caption(f"Each player is dealt {next_round} card{'s' if next_round > 1 else ''}.")
+
+        round_scores = {}
+        cols = st.columns(len(players))
+        for i, player in enumerate(players):
+            with cols[i]:
+                round_scores[player] = st.number_input(
+                    player,
+                    value=0,
+                    step=1,
+                    key=f"sk_input_r{next_round}_{player}",
+                )
+
+        if st.button("Save Round", type="primary", key=f"sk_save_r{next_round}"):
+            st.session_state.sk_scores[next_round] = round_scores
+            st.rerun()
+    else:
+        st.success("Game complete! All 10 rounds played.")
+        _render_final_standings(players, scores, completed_rounds)
+
+
+def _render_scoreboard(players, scores, completed_rounds):
+    header_cols = ["Round"] + players
+    rows_html = []
+
+    cumsum = {p: 0 for p in players}
+    prev_cumsum = {p: 0 for p in players}
+
+    for r in completed_rounds:
+        row = [f"**{r}**"]
+        for p in players:
+            pts = scores[r].get(p, 0)
+            prev_cumsum[p] = cumsum[p]
+            cumsum[p] += pts
+            change = cumsum[p] - prev_cumsum[p]
+            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 = ""
+            row.append(f"**{cumsum[p]}**{indicator}")
+        rows_html.append(row)
+
+    md = "| " + " | ".join(header_cols) + " |\n"
+    md += "| " + " | ".join(["---"] * len(header_cols)) + " |\n"
+    for row in rows_html:
+        md += "| " + " | ".join(str(c) for c in row) + " |\n"
+
+    st.markdown(md, unsafe_allow_html=True)
+
+
+def _render_final_standings(players, scores, completed_rounds):
+    st.subheader("Final Standings")
+    totals = {p: sum(scores[r].get(p, 0) for r in completed_rounds) for p in players}
+    ranked = sorted(totals.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")
+
+
+# Page entry point
+st.title("Skull King")
+_init_state()
+
+if not st.session_state.sk_game_started:
+    _setup_phase()
+else:
+    _game_phase()