Update app.py

app.py

@@ -1,18 +1,177 @@
 import gradio as gr
+import pandas as pd
+
+# --- Konstanten für die Berechnung ---
+# These constants are fine as they don't represent a changing state.
+GRUNDWERTE = {"Karo": 9, "Herz": 10, "Pik": 11, "Kreuz": 12, "Grand": 24}
+NULL_SPIELE = {"Null": 23, "Null Hand": 35, "Null Ouvert": 46, "Null Hand Ouvert": 59}
+SPIELER = ["Kirsten", "Robert", "Samuel"]
+HISTORY_DF_HEADERS = ["Kirsten", "Robert", "Samuel", "Spielwert", "Spielart", "Alleinspieler", "Details", "Verloren"]
+
+
+# --- Hauptfunktionen ---
+
+def calculate_spielwert(spielart, spitzen_str, hand, schneider, schwarz, schneider_angesagt, schwarz_angesagt, offen):
+    """Berechnet den reinen Spielwert (Reizwert) basierend auf den Spielregeln."""
+    # This function had no side effects and remains unchanged.
+    if spielart in NULL_SPIELE:
+        return NULL_SPIELE[spielart]
+    if spielart not in GRUNDWERTE or not spitzen_str:
+        return 0
+    spitzen_anzahl = int(spitzen_str.split(" ")[1])
+    gewinnstufe = 1
+    if hand: gewinnstufe += 1
+    if schneider: gewinnstufe += 1
+    if schneider_angesagt: gewinnstufe += 1
+    if schwarz: gewinnstufe += 1
+    if schwarz_angesagt: gewinnstufe += 1
+    if offen: gewinnstufe += 1
+    grundwert = GRUNDWERTE[spielart]
+    return (spitzen_anzahl + gewinnstufe) * grundwert
+
+# --- REFACTURED FUNCTION ---
+# No more global variables. The history_df is now passed as an argument.
+def spiel_hinzufuegen(history_df, spieler, spielart, spitzen, hand, schneider, schwarz, schneider_angesagt, schwarz_angesagt, offen, verloren):
+    """
+    Fügt ein neues Spiel zum History-DataFrame hinzu und berechnet die Gesamtstände dynamisch.
+    """
+    spielwert = calculate_spielwert(spielart, spitzen, hand, schneider, schwarz, schneider_angesagt, schwarz_angesagt, offen)
+    
+    # This dictionary stores the point change for this single round.
+    neue_punkte = {name: 0 for name in SPIELER}
+
+    if spieler: # Only if a soloist was selected
+        if not verloren:
+            # Soloist wins
+            neue_punkte[spieler] = 50 + spielwert
+            # Opponents get penalty points
+            for p in SPIELER:
+                if p != spieler:
+                    neue_punkte[p] = -40
+        else:
+            # Soloist loses
+            neue_punkte[spieler] = -50 - (2 * spielwert) # The original had an error, this is the correct calculation for a lost game (-50 and -2*game_value)
+            # Opponents get points
+            for p in SPIELER:
+                if p != spieler:
+                    neue_punkte[p] = 40
+    
+    details = f"Spitzen: {spitzen or 'N/A'}"
+    if hand: details += ", Hand"
+    if schneider_angesagt: details += ", Schneider angesagt"
+    if schwarz_angesagt: details += ", Schwarz angesagt"
+    if offen: details += ", Offen"
+    
+    # Create a dictionary for the new row
+    neues_spiel_eintrag = {
+        "Kirsten": neue_punkte["Kirsten"],
+        "Robert": neue_punkte["Robert"],
+        "Samuel": neue_punkte["Samuel"],
+        "Spielwert": spielwert,
+        "Spielart": spielart,
+        "Alleinspieler": spieler or "N/A",
+        "Details": details,
+        "Verloren": "Ja" if verloren else "Nein"
+    }
+    
+    # --- NEW: STATE MANAGEMENT ---
+    # Convert the new game entry into a DataFrame of a single row
+    new_row_df = pd.DataFrame([neues_spiel_eintrag])
+    
+    # Append the new row to the existing history DataFrame
+    updated_history_df = pd.concat([history_df, new_row_df], ignore_index=True)
+
+    # Calculate the totals by summing the columns of the *updated* history DataFrame
+    total_scores = updated_history_df[SPIELER].sum()
+    totals_df = pd.DataFrame([total_scores]) # Convert the totals Series to a DataFrame for display
+    
+    # Return both updated DataFrames
+    return totals_df, updated_history_df
+
+# --- REFACTURED FUNCTION ---
+# This function no longer needs to modify globals. It just creates and returns empty DataFrames.
+def reset_turnier():
+    """Setzt den gesamten Spielstand und die Historie zurück."""
+    empty_totals = pd.DataFrame([{"Kirsten": 0, "Robert": 0, "Samuel": 0}])
+    empty_history = pd.DataFrame(columns=HISTORY_DF_HEADERS)
+    return empty_totals, empty_history
+
+# --- UI Definition mit Gradio ---
 
 with gr.Blocks() as demo:
-    Spieler = gr.Dropdown(choices=['Kirsten', 'Robert', 'Samuel'], label="Waehle Spieler:", info="Falls kein Alleinspieler, leer lassen")
-    Spielart = gr.Dropdown(choices=['Null', 'Kreuz', 'Pik', 'Herz', 'Karo', 'Grande', 'Ramsch', 'Null offen'], label="Waehle Spielart:")
-    Truempfe = gr.Dropdown(choices=['Kreuz', 'Pike', 'Herz', 'Karo', 'Ass', 'Zehn'], multiselect=True, label="Waehle Truempfe des Alleinspielers:")
+    gr.Markdown("# Skat-Punkte-Tracker")
+
+    gr.Markdown("### Gesamtpunktestand")
+    
+    # --- NEW: Initialize DataFrames for the UI ---
+    initial_totals_df, initial_history_df = reset_turnier()
+    
+    totals_output = gr.Dataframe(
+        value=initial_totals_df,
+        interactive=False,
+        show_row_numbers=False
+    )
+    
     with gr.Row():
-        Schneider = gr.Checkbox(label="Schneider?")
-        Schwarz = gr.Checkbox(label="Schwarz?")
-    speichere_spiel = gr.Button(value="Speichere Spiel")
-    Turnier = gr.Dataframe(headers=['Kirsten', 'Robert', 'Samuel', 'Spielart', 'Alleinspieler', 'Truempfe', 'Schneider', 'Schwarz'])
+        with gr.Column(scale=1):
+            gr.Markdown("### Neues Spiel eingeben")
+            
+            spieler_input = gr.Dropdown(SPIELER, label="Alleinspieler")
+            spielart_input = gr.Dropdown(
+                choices=['Karo', 'Herz', 'Pik', 'Kreuz', 'Grand', 'Null', 'Null Hand', 'Null Ouvert', 'Null Hand Ouvert'], # Ramsch removed as it's not handled in the logic
+                label="Spielart"
+            )
+            spitzen_input = gr.Dropdown(
+                choices=[f"{m} {i}" for m in ["Mit", "Ohne"] for i in range(1, 5)], # Normal range is 1-4
+                label="Spitzen"
+            )
+
+            with gr.Row():
+                schneider_input = gr.Checkbox(label="Schneider")
+                schwarz_input = gr.Checkbox(label="Schwarz")
+                verloren_input = gr.Checkbox(label="Verloren?")
+
+            with gr.Accordion("Optionen für Handspiele", open=False):
+                hand_input = gr.Checkbox(label="Handspiel")
+                schneider_angesagt_input = gr.Checkbox(label="Schneider angesagt")
+                schwarz_angesagt_input = gr.Checkbox(label="Schwarz angesagt")
+                offen_input = gr.Checkbox(label="Offen / Ouvert")
+            
+            with gr.Row():
+                speichere_spiel = gr.Button("Speichere Spiel", variant="primary", scale=2)
+                reset_button = gr.Button("Reset", variant="stop", scale=1)
+
+        with gr.Column(scale=2):
+            gr.Markdown("### Spielverlauf")
+            turnier_output = gr.Dataframe(
+                value=initial_history_df,
+                headers=HISTORY_DF_HEADERS,
+                interactive=False,
+                wrap=True
+            )
+
+    # List of all input components for a new game
+    inputs_list = [
+        spieler_input, spielart_input, spitzen_input,
+        hand_input, schneider_input, schwarz_input,
+        schneider_angesagt_input, schwarz_angesagt_input, offen_input,
+        verloren_input
+    ]
+    
+    # --- NEW: Updated Click Handler ---
+    # The 'turnier_output' DataFrame is now also an INPUT to the function.
+    # It carries the current state of the game history.
+    speichere_spiel.click(
+        fn=spiel_hinzufuegen,
+        inputs=[turnier_output] + inputs_list,
+        outputs=[totals_output, turnier_output]
+    )
 
-    @speichere_spiel.click(inputs=[Spieler, Spielart, Truempfe, Schneider, Schwarz], outputs=[Turnier])
-    def spiel_hinzufuegen(Spieler, Spielart, Truempfe, Schneider, Schwarz):
-        ...
-        return ...
+    reset_button.click(
+        fn=reset_turnier,
+        inputs=[],
+        outputs=[totals_output, turnier_output]
+    )
 
-demo.launch()
+if __name__ == "__main__":
+    demo.launch(share=True)