""" Hauptreiter SQUAD: Konto, alle Charaktere, Squads und Einladungen. Solange ein PC nicht mitmacht, zeigt der Reiter den Einstieg: Mitmachen mit einem Spielernamen (der PC bekommt einen Schluessel, kein Konto noetig) oder Anmelden mit einem gesicherten Konto. Alles andere im Programm geht auch ohne. Wer mitmacht, sieht drei Unterreiter: Charaktere alle Charaktere aller Spieler mit Zustand (KIA, MIA ...) Squads alle Squads, eigene verwalten, neues gruenden Einladungen erhaltene annehmen oder ablehnen, verschickte zurueckziehen Dazu steuert AbgleichSteuerung, wann die eigenen Akten mit dem Server abgeglichen werden. Alle Serveraufrufe laufen ueber hintergrund.py, damit das Fenster nie einfriert. """ import io import time import tkinter as tk import webbrowser from tkinter import messagebox, ttk from PIL import Image, ImageOps, ImageTk import abgleich import akte import akte_modell as modell import akte_vorlagen as vorlagen import konto from hintergrund import Hintergrund from theme import (AMBER, BG, FG, FG_DIM, FONT_BOLD, FONT_UI, OLIVE_HI, PANEL, RED, dunkle_titelleiste) ALLE_FRAKTIONEN = "Alle Fraktionen" ZUSTAND = { "aktiv": ("", "aktiv"), "verwundet": ("WIA", "verwundet"), "vermisst": ("MIA", "vermisst"), "gefallen": ("KIA", "gefallen"), "außer Dienst": ("a. D.", "außer Dienst"), } def zustand_text(status): kurz, lang = ZUSTAND.get(status, ("", status or "aktiv")) return f"{kurz} · {lang}" if kurz else lang def charakter_name(c): name = " ".join(t for t in (c.get("vorname", ""), c.get("nachname", "")) if t) if c.get("callsign"): return f'{c["callsign"]} · {c.get("nachname") or name}' if name else c["callsign"] return name or c.get("aktennummer") or "Ohne Namen" def fehlertext(fehler): if isinstance(fehler, konto.ServerFehler): return fehler.meldung return f"Unerwarteter Fehler: {fehler}" def dialog_zentrieren(fenster, eltern): dunkle_titelleiste(fenster) fenster.update_idletasks() oben = eltern.winfo_toplevel() x = oben.winfo_rootx() + (oben.winfo_width() - fenster.winfo_width()) // 2 y = oben.winfo_rooty() + (oben.winfo_height() - fenster.winfo_height()) // 3 fenster.geometry(f"+{max(x, 0)}+{max(y, 0)}") # -- Abgleich ---------------------------------------------------------------------- class AbgleichSteuerung: """Stoesst den Abgleich an: nach dem Anmelden, kurz nach Aenderungen und regelmaessig.""" NACH_AENDERUNG_MS = 4000 TAKT_MS = 5 * 60 * 1000 def __init__(self, widget, hintergrund, akte_seite, protokollieren, bei_abmeldung): self.widget = widget self.hintergrund = hintergrund self.akte_seite = akte_seite self.protokollieren = protokollieren self.bei_abmeldung = bei_abmeldung self.beobachter = [akte_seite.abgleich_zustand] self._job = None self._laeuft = False self._erneut = False akte_seite.bei_gespeichert = lambda: self.anstossen(self.NACH_AENDERUNG_MS) self.melden() widget.after(1500, self._takt) def melden(self, text=None, art="aus"): if text is None: text, art = ("Abgleich folgt", "aus") if konto.angemeldet() \ else ("Nur auf diesem PC – im Reiter SQUAD kannst du mitmachen", "aus") for beobachter in self.beobachter: beobachter(text, art) def anstossen(self, verzoegerung_ms=0): if not konto.angemeldet(): self.melden() return if self._job is not None: self.widget.after_cancel(self._job) self._job = self.widget.after(verzoegerung_ms, self._starten) def _starten(self): self._job = None if self._laeuft: self._erneut = True return self._laeuft = True self.akte_seite.speichern_sofort() self.melden("Abgleich läuft …", "laeuft") self.hintergrund.starten(abgleich.abgleichen, self._fertig, self._fehler) def _nachlauf(self): self._laeuft = False if self._erneut: self._erneut = False self.anstossen(500) def _fertig(self, ergebnis): if ergebnis is not None: self.akte_seite.nach_abgleich(ergebnis["geaendert"]) text = f"Mit dem Server abgeglichen · {time.strftime('%H:%M')}" if ergebnis["konflikte"]: text += (f" · {ergebnis['konflikte']} Konflikt(e): die Serverfassung liegt als " "konflikt-Datei im Aktenordner") self.melden(text, "offline" if ergebnis["konflikte"] else "ok") self._nachlauf() def _fehler(self, fehler): if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet": self.melden("Der Server kennt diesen PC nicht mehr – im Reiter SQUAD neu mitmachen " "oder anmelden", "fehler") self.bei_abmeldung() elif isinstance(fehler, konto.ServerFehler) and fehler.code == "offline": self.melden("Offline – Änderungen werden später hochgeladen", "offline") else: self.protokollieren(type(fehler), fehler, fehler.__traceback__) self.melden(f"Abgleich gescheitert: {fehlertext(fehler)}", "fehler") self._nachlauf() def _takt(self): if konto.angemeldet(): self.anstossen() try: self.widget.after(self.TAKT_MS, self._takt) except tk.TclError: pass # -- Anmeldung und Registrierung ------------------------------------------------------ class AnmeldeFlaeche(ttk.Frame): """ Einstieg in den Squad-Reiter. Mitmachen braucht nur einen Spielernamen - der PC bekommt einen Schluessel. Anmelden gibt es fuer gesicherte Konten, etwa auf einem zweiten PC. """ def __init__(self, master, hintergrund, bei_anmeldung): super().__init__(master) self.hintergrund = hintergrund self.bei_anmeldung = bei_anmeldung self._knoepfe = [] mitte = ttk.Frame(self) mitte.place(relx=0.5, rely=0.42, anchor="center") ttk.Label(mitte, text="SQUAD", font=("Segoe UI Semibold", 16)).pack(anchor="w") ttk.Label(mitte, style="Dim.TLabel", justify="left", wraplength=440, text=( "Mach mit, um die Charaktere der anderen Spieler zu sehen und Squads zu bilden. " "Deine Akten werden dann für alle sichtbar. Ein Konto brauchst du dafür nicht – " "dieser PC bekommt einen eigenen Schlüssel.\n\n" "Ohne Mitmachen bleiben deine Akten nur auf diesem PC.")).pack(anchor="w", pady=(4, 14)) reiter = ttk.Notebook(mitte) reiter.pack(fill="x") self.reiter = reiter self._mitmachen_aufbauen(reiter) self._anmelden_aufbauen(reiter) self.meldung_var = tk.StringVar() self.meldung = ttk.Label(mitte, textvariable=self.meldung_var, wraplength=440, justify="left") self.meldung.pack(anchor="w", pady=(12, 0)) self.erneut_knopf = ttk.Button(mitte, text="Bestätigungsmail erneut senden", command=self.bestaetigung_erneut) verweise = ttk.Frame(mitte) verweise.pack(anchor="w", pady=(14, 0)) for text, ziel in (("Passwort vergessen?", konto.webseite("/konto/vergessen.php")), ("Impressum und Datenschutz", "https://tyrveil.com/rechtliches#impressum")): verweis = ttk.Label(verweise, text=text, style="Dim.TLabel", cursor="hand2") verweis.pack(side="left", padx=(0, 18)) verweis.bind("", lambda e, z=ziel: webbrowser.open(z)) @staticmethod def _feld(eltern, zeile, beschriftung, verdeckt=False): ttk.Label(eltern, text=beschriftung).grid(row=zeile, column=0, sticky="w", pady=5, padx=(0, 12)) var = tk.StringVar() eingabe = ttk.Entry(eltern, textvariable=var, width=34, show="•" if verdeckt else "") eingabe.grid(row=zeile, column=1, sticky="ew", pady=5) return var, eingabe def _mitmachen_aufbauen(self, reiter): f = ttk.Frame(reiter, padding=16) reiter.add(f, text="Mitmachen") self.spielername_var, eingabe = self._feld(f, 0, "Spielername") eingabe.bind("", lambda e: self.mitmachen()) ttk.Label(f, style="Dim.TLabel", wraplength=380, justify="left", text="3 bis 32 Zeichen, etwa dein Discord- oder Steam-Name. Für alle sichtbar.").grid( row=1, column=0, columnspan=2, sticky="w") knopf = ttk.Button(f, text="Mitmachen", style="Accent.TButton", command=self.mitmachen) knopf.grid(row=2, column=1, sticky="e", pady=(10, 0)) self._knoepfe.append(knopf) def _anmelden_aufbauen(self, reiter): f = ttk.Frame(reiter, padding=16) reiter.add(f, text="Mit Konto anmelden") self.login_var, erstes = self._feld(f, 0, "Benutzername oder E-Mail") self.passwort_var, pw = self._feld(f, 1, "Passwort", verdeckt=True) ttk.Label(f, style="Dim.TLabel", wraplength=380, justify="left", text="Für Konten, die mit E-Mail und Passwort gesichert sind – etwa auf einem zweiten PC." ).grid(row=2, column=0, columnspan=2, sticky="w") knopf = ttk.Button(f, text="Anmelden", style="Accent.TButton", command=self.anmelden) knopf.grid(row=3, column=1, sticky="e", pady=(10, 0)) self._knoepfe.append(knopf) for eingabe in (erstes, pw): eingabe.bind("", lambda e: self.anmelden()) def _zeigen(self, text, art="info"): farben = {"info": FG, "ok": OLIVE_HI, "fehler": RED, "warnung": AMBER} self.meldung_var.set(text) self.meldung.configure(foreground=farben.get(art, FG)) def _beschaeftigt(self, ja): for knopf in self._knoepfe: knopf.configure(state="disabled" if ja else "normal") def mitmachen(self): name = self.spielername_var.get().strip() if not name: self._zeigen("Bitte einen Spielernamen eingeben.", "warnung") return self._beschaeftigt(True) self._zeigen("Einen Moment …") def fertig(nutzer): self._beschaeftigt(False) self._zeigen("") self.bei_anmeldung(nutzer) def fehler(f): self._beschaeftigt(False) self._zeigen(fehlertext(f), "fehler") self.hintergrund.starten(lambda: konto.mitmachen(name), fertig, fehler) def anmelden(self): login, passwort = self.login_var.get().strip(), self.passwort_var.get() if not login or not passwort: self._zeigen("Bitte Benutzername oder E-Mail und Passwort eingeben.", "warnung") return self.erneut_knopf.pack_forget() self._beschaeftigt(True) self._zeigen("Melde an …") def fertig(nutzer): self._beschaeftigt(False) self.passwort_var.set("") self._zeigen("") self.bei_anmeldung(nutzer) def fehler(f): self._beschaeftigt(False) self._zeigen(fehlertext(f), "fehler") if isinstance(f, konto.ServerFehler) and f.code == "nicht_bestaetigt": self.erneut_knopf.pack(anchor="w", pady=(8, 0)) self.hintergrund.starten(lambda: konto.anmelden(login, passwort), fertig, fehler) def bestaetigung_erneut(self): email = self.login_var.get().strip() if "@" not in email: self._zeigen("Trage oben deine E-Mail-Adresse ein, dann schicken wir die Mail erneut.", "warnung") return self.hintergrund.starten(lambda: konto.bestaetigung_erneut(email), lambda antwort: self._zeigen(antwort.get("meldung", "Mail ist unterwegs."), "ok"), lambda f: self._zeigen(fehlertext(f), "fehler")) # -- Fremde Akte ansehen ---------------------------------------------------------------- def akte_fenster(eltern, charakter, bild_bytes): """Zeigt eine Akte vom Server als Dokument in einem eigenen Fenster.""" fenster = tk.Toplevel(eltern) fenster.title(f"Akte {charakter.get('aktennummer') or ''} – {charakter_name(charakter)}") fenster.configure(bg=BG) fenster.geometry("720x820") fenster.transient(eltern.winfo_toplevel()) leinwand = tk.Canvas(fenster, bg=BG, highlightthickness=0, bd=0) leiste = ttk.Scrollbar(fenster, orient="vertical", command=leinwand.yview) leinwand.configure(yscrollcommand=leiste.set) leiste.pack(side="right", fill="y") leinwand.pack(side="left", fill="both", expand=True) daten = modell.migrieren(dict(charakter.get("daten") or {})) daten["aktennummer"] = charakter.get("aktennummer") or daten.get("aktennummer", "") fotos = {} def foto_fuer(groesse): if not bild_bytes: return None if groesse not in fotos: with Image.open(io.BytesIO(bild_bytes)) as bild: fotos[groesse] = ImageTk.PhotoImage(ImageOps.contain(bild.convert("RGBA"), groesse)) return fotos[groesse] zeichnen = lambda e=None: akte.dokument_zeichnen(leinwand, daten, foto_fuer) # noqa: E731 leinwand.bind("", zeichnen) leinwand.bind("", lambda e: leinwand.yview_scroll(int(-e.delta / 120), "units")) fenster.bind("", lambda e: fenster.destroy()) dialog_zentrieren(fenster, eltern) return fenster # -- Hauptreiter ------------------------------------------------------------------------ def _tabelle(eltern, spalten, hoehe=12): rahmen = ttk.Frame(eltern) baum = ttk.Treeview(rahmen, columns=[s for s, _, _ in spalten], show="headings", selectmode="browse", height=hoehe) for schluessel, titel, breite in spalten: baum.heading(schluessel, text=titel, anchor="w") baum.column(schluessel, width=breite, anchor="w", stretch=True) leiste = ttk.Scrollbar(rahmen, orient="vertical", command=baum.yview) baum.configure(yscrollcommand=leiste.set) baum.pack(side="left", fill="both", expand=True) leiste.pack(side="right", fill="y") baum.tag_configure("kia", foreground=RED) baum.tag_configure("mia", foreground=AMBER) baum.tag_configure("wia", foreground=AMBER) baum.tag_configure("ad", foreground=FG_DIM) baum.tag_configure("eigener", foreground=OLIVE_HI) return rahmen, baum def _zustand_tag(status): return {"gefallen": "kia", "vermisst": "mia", "verwundet": "wia", "außer Dienst": "ad"}.get(status, "") class SquadSeite(ttk.Frame): def __init__(self, master, akte_seite, protokollieren): super().__init__(master) self.hintergrund = Hintergrund(self) self.akte_seite = akte_seite self.protokollieren = protokollieren self.charaktere = [] self.squads = [] self.einladungen = {"eingang": [], "ausgang": []} self._bilder = {} self._zuletzt_geladen = 0.0 self._laedt = False self.abgleich = AbgleichSteuerung(self, self.hintergrund, akte_seite, protokollieren, bei_abmeldung=self._abgemeldet) self.anmeldung = AnmeldeFlaeche(self, self.hintergrund, self._angemeldet) self.inhalt = ttk.Frame(self) self._inhalt_aufbauen() self.abgleich.beobachter.append(self._abgleich_zustand) self._ansicht() if konto.angemeldet(): # Pruefen, ob die gespeicherte Anmeldung noch gilt self.hintergrund.starten(konto.pruefen, lambda nutzer: self._ansicht(), self._pruefung_gescheitert) # -- Umschalten ----------------------------------------------------------------- def _ansicht(self): if konto.angemeldet(): self.anmeldung.pack_forget() self.inhalt.pack(fill="both", expand=True) self._kopf_aktualisieren() else: self.inhalt.pack_forget() self.anmeldung.pack(fill="both", expand=True) def _pruefung_gescheitert(self, fehler): if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet": self._abgemeldet() def _angemeldet(self, nutzer): self._ansicht() self.abgleich.anstossen(0) self.aktualisieren() def _abgemeldet(self): self.charaktere, self.squads = [], [] self.einladungen = {"eingang": [], "ausgang": []} self._ansicht() self.abgleich.melden() def abmelden(self): if not messagebox.askyesno("Abmelden", "Abmelden? Deine Akten bleiben auf diesem PC und werden " "nach der nächsten Anmeldung wieder abgeglichen.", parent=self): return self.hintergrund.starten(konto.abmelden, lambda _: self._abgemeldet(), lambda f: self._abgemeldet()) # -- Konto -------------------------------------------------------------------------- def _kopf_aktualisieren(self): nutzer = konto.nutzer() or {} self.nutzer_var.set(f"Spieler: {nutzer.get('benutzername', '?')}") if not nutzer.get("gesichert", True): text = ("Deine Charaktere hängen nur am Schlüssel dieses PCs. Nach einem Reset wären sie " "nicht mehr bearbeitbar – Konto sichern …") elif not nutzer.get("bestaetigt", True): text = "E-Mail-Adresse noch nicht bestätigt – den Link in der Mail öffnen. Erneut senden …" else: text = "" self.sichern_text.configure(text=text) if text: self.sichern_zeile.pack(fill="x", pady=(0, 6), before=self.nb) else: self.sichern_zeile.pack_forget() def _hinweis_geklickt(self): nutzer = konto.nutzer() or {} if not nutzer.get("gesichert", True): self.konto_sichern() elif not nutzer.get("bestaetigt", True): self._bestaetigung_erneut() def _konto_menue_fuellen(self): menue = self.konto_menue menue.delete(0, "end") nutzer = konto.nutzer() or {} if nutzer.get("gesichert", True): if not nutzer.get("bestaetigt", True): menue.add_command(label="Bestätigungsmail erneut senden", command=self._bestaetigung_erneut) menue.add_command(label="Abmelden", command=self.abmelden) else: # Kein Abmelden: Das loeschte den Schluessel, und die Charaktere waeren verwaist menue.add_command(label="Konto sichern …", command=self.konto_sichern) menue.add_separator() menue.add_command(label="Konto löschen …", command=self.konto_loeschen) def _bestaetigung_erneut(self): email = (konto.nutzer() or {}).get("email") if email: self.hintergrund.starten(lambda: konto.bestaetigung_erneut(email), lambda _: self.status_var.set(f"Bestätigungsmail an {email} ist unterwegs."), lambda f: messagebox.showerror("Konto", fehlertext(f), parent=self)) def konto_sichern(self): """E-Mail und Passwort an den Schluessel haengen.""" fenster = tk.Toplevel(self) fenster.title("Konto sichern") fenster.configure(bg=BG) fenster.resizable(False, False) fenster.transient(self.winfo_toplevel()) f = ttk.Frame(fenster, padding=18) f.pack(fill="both") ttk.Label(f, wraplength=400, justify="left", text=( "Mit E-Mail und Passwort überstehen deine Charaktere einen PC-Reset, und du kannst " "dich auch auf einem zweiten PC anmelden. Dein Spielername bleibt gleich.")).grid( row=0, column=0, columnspan=2, sticky="w", pady=(0, 10)) felder = {} for zeile, (schluessel, text, verdeckt) in enumerate((("email", "E-Mail", False), ("pw", "Passwort (mind. 10 Zeichen)", True), ("pw2", "Passwort wiederholen", True)), start=1): ttk.Label(f, text=text).grid(row=zeile, column=0, sticky="w", pady=5, padx=(0, 12)) felder[schluessel] = tk.StringVar() ttk.Entry(f, textvariable=felder[schluessel], width=32, show="•" if verdeckt else "").grid( row=zeile, column=1, sticky="ew", pady=5) meldung = ttk.Label(f, text="", foreground=RED, wraplength=400, justify="left") meldung.grid(row=4, column=0, columnspan=2, sticky="w", pady=(6, 0)) def sichern(): email, pw = felder["email"].get().strip(), felder["pw"].get() if pw != felder["pw2"].get(): meldung.configure(text="Die beiden Passwörter stimmen nicht überein.") return meldung.configure(text="Einen Moment …", foreground=FG_DIM) def fertig(_): fenster.destroy() self._kopf_aktualisieren() messagebox.showinfo("Konto sichern", f"Fast geschafft: Bestätige den Link in der Mail an {email}. " "Danach kannst du dich auch auf anderen PCs mit E-Mail und Passwort anmelden.", parent=self) self.hintergrund.starten(lambda: konto.konto_sichern(email, pw), fertig, lambda fehler: meldung.configure(text=fehlertext(fehler), foreground=RED)) knoepfe = ttk.Frame(f) knoepfe.grid(row=5, column=0, columnspan=2, sticky="e", pady=(12, 0)) ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right") ttk.Button(knoepfe, text="Sichern", style="Accent.TButton", command=sichern).pack(side="right", padx=(0, 8)) fenster.bind("", lambda e: fenster.destroy()) dialog_zentrieren(fenster, self) fenster.grab_set() def konto_loeschen(self): """Loescht das Konto samt Akten auf dem Server. Die lokalen Akten bleiben.""" fenster = tk.Toplevel(self) fenster.title("Konto löschen") fenster.configure(bg=BG) fenster.resizable(False, False) fenster.transient(self.winfo_toplevel()) f = ttk.Frame(fenster, padding=18) f.pack(fill="both") ttk.Label(f, wraplength=380, justify="left", text=( "Das Konto wird mit allen Charakteren auf dem Server gelöscht. Führt einer " "deiner Charaktere ein Squad, übernimmt das dienstälteste Mitglied.\n\n" "Deine Akten auf diesem PC bleiben erhalten. Das lässt sich nicht rückgängig machen.") ).grid(row=0, column=0, columnspan=2, sticky="w") passwort = tk.StringVar() mit_passwort = konto.gesichert() eingabe = None if mit_passwort: ttk.Label(f, text="Passwort zur Bestätigung").grid(row=1, column=0, sticky="w", pady=(14, 0), padx=(0, 12)) eingabe = ttk.Entry(f, textvariable=passwort, show="•", width=28) eingabe.grid(row=1, column=1, sticky="ew", pady=(14, 0)) def loeschen(): wert = passwort.get() if wert or not mit_passwort: fenster.destroy() self.konto_loeschen_ausfuehren(wert) knoepfe = ttk.Frame(f) knoepfe.grid(row=2, column=0, columnspan=2, sticky="e", pady=(16, 0)) ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right") ttk.Button(knoepfe, text="Endgültig löschen", command=loeschen).pack(side="right", padx=(0, 8)) fenster.bind("", lambda e: fenster.destroy()) dialog_zentrieren(fenster, self) fenster.grab_set() if eingabe is not None: eingabe.focus_set() def konto_loeschen_ausfuehren(self, passwort, bestaetigen=True): def arbeit(): konto.aufrufen("konto_loeschen", passwort=passwort) # Lokale Akten gelten danach als nie abgeglichen - bei einem neuen # Konto werden sie wieder hochgeladen statt in den Papierkorb geraeumt for eintrag in modell.alle_akten(): (modell.ordner_von(eintrag["id"]) / abgleich.META).unlink(missing_ok=True) konto.abmelden() def fertig(_): self._abgemeldet() if bestaetigen: messagebox.showinfo("Konto gelöscht", "Dein Konto ist gelöscht.", parent=self) self.hintergrund.starten(arbeit, fertig, lambda fehler: messagebox.showerror("Konto löschen", fehlertext(fehler), parent=self)) def sichtbar(self): """Vom Hauptfenster aufgerufen, wenn der Reiter gewaehlt wird.""" if konto.angemeldet() and time.time() - self._zuletzt_geladen > 20: self.aktualisieren() # -- Aufbau ----------------------------------------------------------------------- def _inhalt_aufbauen(self): kopf = ttk.Frame(self.inhalt) kopf.pack(fill="x", pady=(8, 6)) self.nutzer_var = tk.StringVar() ttk.Label(kopf, textvariable=self.nutzer_var, font=FONT_BOLD).pack(side="left") konto_menue = ttk.Menubutton(kopf, text="Konto") # Die Eintraege haengen davon ab, ob das Konto gesichert ist - beim Oeffnen neu fuellen self.konto_menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI, activeforeground="#12150f", font=FONT_UI, postcommand=self._konto_menue_fuellen) konto_menue["menu"] = self.konto_menue konto_menue.pack(side="right") # Solange das Konto nur am Schluessel dieses PCs haengt, daran erinnern self.sichern_zeile = ttk.Frame(self.inhalt) self.sichern_text = ttk.Label(self.sichern_zeile, foreground=AMBER, cursor="hand2", wraplength=820) self.sichern_text.pack(side="left") self.sichern_text.bind("", lambda e: self._hinweis_geklickt()) ttk.Button(kopf, text="Aktualisieren", command=self.aktualisieren).pack(side="right", padx=(0, 6)) self.status_var = tk.StringVar() self.status = ttk.Label(kopf, textvariable=self.status_var, style="Dim.TLabel") self.status.pack(side="left", padx=(16, 0)) nb = ttk.Notebook(self.inhalt) nb.pack(fill="both", expand=True) self.nb = nb self.sichern_zeile.pack(fill="x", pady=(0, 6), before=nb) self._charaktere_aufbauen(nb) self._squads_aufbauen(nb) self._einladungen_aufbauen(nb) def _charaktere_aufbauen(self, nb): seite = ttk.Frame(nb, padding=10) nb.add(seite, text="Charaktere") seite.columnconfigure(0, weight=1) seite.rowconfigure(1, weight=1) filter_ = ttk.Frame(seite) filter_.grid(row=0, column=0, columnspan=2, sticky="ew", pady=(0, 8)) self.suche_var = tk.StringVar() suche = ttk.Entry(filter_, textvariable=self.suche_var, width=24) suche.pack(side="left") suche.bind("", lambda e: self.aktualisieren()) self.fraktion_var = tk.StringVar(value=ALLE_FRAKTIONEN) fraktion = ttk.Combobox(filter_, textvariable=self.fraktion_var, state="readonly", width=28, values=[ALLE_FRAKTIONEN] + vorlagen.fraktionsnamen()) fraktion.pack(side="left", padx=8) fraktion.bind("<>", lambda e: self.aktualisieren()) fraktion.bind("", lambda e: "break") ttk.Button(filter_, text="Suchen", command=self.aktualisieren).pack(side="left") rahmen, self.liste = _tabelle(seite, [("name", "Charakter", 170), ("rang", "Dienstgrad", 150), ("zustand", "Zustand", 90), ("squad", "Squad", 110), ("spieler", "Spieler", 90)]) rahmen.grid(row=1, column=0, sticky="nsew") self.liste.bind("<>", lambda e: self._charakter_gewaehlt()) self.liste.bind("", lambda e: self.akte_ansehen()) detail = ttk.Frame(seite, width=240) detail.grid(row=1, column=1, sticky="nsew", padx=(12, 0)) detail.grid_propagate(False) self.bild = tk.Label(detail, bg=PANEL, fg=FG_DIM, text="kein\nPorträt", font=FONT_UI, width=20, height=10) self.bild.pack(anchor="w") self.detail_titel = ttk.Label(detail, text="", font=("Segoe UI Semibold", 13), wraplength=230) self.detail_titel.pack(anchor="w", pady=(8, 2)) self.detail_text = ttk.Label(detail, text="Wähle links einen Charakter.", style="Dim.TLabel", wraplength=230, justify="left") self.detail_text.pack(anchor="w") self.knopf_ansehen = ttk.Button(detail, text="Akte ansehen", command=self.akte_ansehen) self.knopf_ansehen.pack(anchor="w", fill="x", pady=(10, 4)) self.knopf_einladen = ttk.Button(detail, text="In mein Squad einladen", style="Accent.TButton", command=self.einladen) self.knopf_einladen.pack(anchor="w", fill="x") self.einladen_hinweis = ttk.Label(detail, text="", style="Dim.TLabel", wraplength=230) self.einladen_hinweis.pack(anchor="w", pady=(4, 0)) self._detail_leeren() def _squads_aufbauen(self, nb): seite = ttk.Frame(nb, padding=10) nb.add(seite, text="Squads") seite.columnconfigure(0, weight=2) seite.columnconfigure(1, weight=3) seite.rowconfigure(1, weight=1) ttk.Button(seite, text="Squad gründen …", style="Accent.TButton", command=self.squad_gruenden).grid(row=0, column=0, sticky="w", pady=(0, 8)) rahmen, self.squad_liste = _tabelle(seite, [("name", "Squad", 150), ("fuehrer", "Führer", 120), ("staerke", "Stärke", 55)]) rahmen.grid(row=1, column=0, sticky="nsew") self.squad_liste.bind("<>", lambda e: self._squad_gewaehlt()) rechts = ttk.Frame(seite) rechts.grid(row=1, column=1, sticky="nsew", padx=(12, 0)) rechts.rowconfigure(2, weight=1) rechts.columnconfigure(0, weight=1) self.squad_titel = ttk.Label(rechts, text="Wähle ein Squad.", font=("Segoe UI Semibold", 13)) self.squad_titel.grid(row=0, column=0, sticky="w") self.squad_beschreibung = ttk.Label(rechts, text="", style="Dim.TLabel", wraplength=420, justify="left") self.squad_beschreibung.grid(row=1, column=0, sticky="w", pady=(2, 8)) rahmen, self.mitglieder = _tabelle(rechts, [("name", "Mitglied", 150), ("rang", "Dienstgrad", 140), ("zustand", "Zustand", 80), ("spieler", "Spieler", 80)], 8) rahmen.grid(row=2, column=0, sticky="nsew") self.mitglieder.bind("<>", lambda e: self._squad_knoepfe()) knoepfe = ttk.Frame(rechts) knoepfe.grid(row=3, column=0, sticky="w", pady=(8, 0)) self.knopf_entfernen = ttk.Button(knoepfe, text="Entfernen", command=self.mitglied_entfernen) self.knopf_uebergeben = ttk.Button(knoepfe, text="Führung übergeben", command=self.fuehrung_uebergeben) self.knopf_verlassen = ttk.Button(knoepfe, text="Squad verlassen", command=self.squad_verlassen) self.knopf_aufloesen = ttk.Button(knoepfe, text="Squad auflösen", command=self.squad_aufloesen) for knopf in (self.knopf_entfernen, self.knopf_uebergeben, self.knopf_verlassen, self.knopf_aufloesen): knopf.pack(side="left", padx=(0, 6)) self._squad_knoepfe() def _einladungen_aufbauen(self, nb): seite = ttk.Frame(nb, padding=10) nb.add(seite, text="Einladungen") self.einladungen_seite = seite seite.columnconfigure(0, weight=1) seite.rowconfigure(1, weight=1) seite.rowconfigure(4, weight=1) ttk.Label(seite, text="ERHALTEN", style="Dim.TLabel").grid(row=0, column=0, sticky="w") rahmen, self.eingang = _tabelle(seite, [("squad", "Squad", 170), ("fuer", "Für deinen Charakter", 190), ("von", "Eingeladen von", 190)], 6) rahmen.grid(row=1, column=0, sticky="nsew") knoepfe = ttk.Frame(seite) knoepfe.grid(row=2, column=0, sticky="w", pady=(6, 14)) ttk.Button(knoepfe, text="Annehmen", style="Accent.TButton", command=lambda: self.einladung_beantworten(True)).pack(side="left", padx=(0, 6)) ttk.Button(knoepfe, text="Ablehnen", command=lambda: self.einladung_beantworten(False)).pack(side="left") ttk.Label(seite, text="VERSCHICKT", style="Dim.TLabel").grid(row=3, column=0, sticky="w") rahmen, self.ausgang = _tabelle(seite, [("squad", "Squad", 170), ("charakter", "Eingeladen", 190), ("spieler", "Spieler", 190)], 5) rahmen.grid(row=4, column=0, sticky="nsew") ttk.Button(seite, text="Zurückziehen", command=self.einladung_zurueckziehen).grid( row=5, column=0, sticky="w", pady=(6, 0)) # -- Laden ------------------------------------------------------------------------ def _abgleich_zustand(self, text, art): if not self._laedt: self.status_var.set(text) def aktualisieren(self): if not konto.angemeldet() or self._laedt: return self._laedt = True self.status_var.set("Lädt …") suche = self.suche_var.get().strip() fraktion = "" if self.fraktion_var.get() == ALLE_FRAKTIONEN else self.fraktion_var.get() def arbeit(): konto.pruefen() # frischer Kontostand, etwa ob die E-Mail inzwischen bestaetigt ist return (konto.aufrufen("charaktere_alle", suche=suche, fraktion=fraktion)["charaktere"], konto.aufrufen("squads")["squads"], konto.aufrufen("einladungen")) self.hintergrund.starten(arbeit, self._geladen, self._laden_gescheitert) def _laden_gescheitert(self, fehler): self._laedt = False if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet": self._abgemeldet() return self.status_var.set(fehlertext(fehler)) def _geladen(self, ergebnis): self._laedt = False self._zuletzt_geladen = time.time() self._kopf_aktualisieren() self.charaktere, self.squads, einladungen = ergebnis self.einladungen = {"eingang": einladungen.get("eingang", []), "ausgang": einladungen.get("ausgang", [])} self.status_var.set(f"{len(self.charaktere)} Charaktere · {len(self.squads)} Squads · " f"Stand {time.strftime('%H:%M')}") self._liste_fuellen() self._squads_fuellen() self._einladungen_fuellen() def _ersetzen(self, baum, zeilen): auswahl = baum.selection() baum.delete(*baum.get_children()) for iid, werte, tags in zeilen: baum.insert("", "end", iid=iid, values=werte, tags=tags) if auswahl and baum.exists(auswahl[0]): baum.selection_set(auswahl[0]) def _liste_fuellen(self): zeilen = [] for c in self.charaktere: tags = tuple(t for t in (_zustand_tag(c["status"]), "eigener" if c["eigener"] else "") if t) zeilen.append((str(c["id"]), (charakter_name(c), c["rang"], zustand_text(c["status"]), (c.get("squad") or {}).get("name", "—"), c["spieler"]), tags)) self._ersetzen(self.liste, zeilen) self._charakter_gewaehlt() def _squads_fuellen(self): zeilen = [] for s in self.squads: fuehrer = next((m for m in s["mitglieder"] if m["id"] == s["fuehrer_id"]), None) zeilen.append((str(s["id"]), (s["name"], charakter_name(fuehrer) if fuehrer else "—", len(s["mitglieder"])), ())) self._ersetzen(self.squad_liste, zeilen) self._squad_gewaehlt() def _einladungen_fuellen(self): self._ersetzen(self.eingang, [ (str(e["id"]), ((e.get("squad") or {}).get("name", "?"), charakter_name(e.get("charakter") or {}), charakter_name(e.get("von") or {}) + f" ({(e.get('von') or {}).get('spieler', '?')})"), ()) for e in self.einladungen["eingang"]]) self._ersetzen(self.ausgang, [ (str(e["id"]), ((e.get("squad") or {}).get("name", "?"), charakter_name(e.get("charakter") or {}), (e.get("charakter") or {}).get("spieler", "?")), ()) for e in self.einladungen["ausgang"]]) anzahl = len(self.einladungen["eingang"]) self.nb.tab(self.einladungen_seite, text=f"Einladungen ({anzahl})" if anzahl else "Einladungen") # -- Charaktere ------------------------------------------------------------------- def _gewaehlter(self): auswahl = self.liste.selection() return next((c for c in self.charaktere if str(c["id"]) == auswahl[0]), None) if auswahl else None def _eigene_ids(self): return {c["id"] for c in self.charaktere if c["eigener"]} def _meine_gefuehrten_squads(self): eigene = self._eigene_ids() return [s for s in self.squads if s["fuehrer_id"] in eigene] def _detail_leeren(self): self.bild.configure(image="", text="kein\nPorträt", width=20, height=10) self.detail_titel.configure(text="") self.detail_text.configure(text="Wähle links einen Charakter.") self.knopf_ansehen.configure(state="disabled") self.knopf_einladen.configure(state="disabled") self.einladen_hinweis.configure(text="") def _charakter_gewaehlt(self): c = self._gewaehlter() if c is None: self._detail_leeren() return self.detail_titel.configure(text=c["callsign"] or charakter_name(c)) zeilen = [ " ".join(t for t in (c["rang"], c["vorname"], c["nachname"]) if t), " · ".join(t for t in (c["fraktion"], c["teilstreitkraft"]) if t), c["verwendung"], f"Zustand: {zustand_text(c['status'])}", f"Squad: {(c.get('squad') or {}).get('name', '—')}", f"Spieler: {c['spieler']}" + (" (du)" if c["eigener"] else ""), c.get("aktennummer") or "", ] self.detail_text.configure(text="\n".join(z for z in zeilen if z)) self.knopf_ansehen.configure(state="normal") gefuehrt = self._meine_gefuehrten_squads() hinweis = "" if c.get("squad"): hinweis = "Ist schon in einem Squad." elif not gefuehrt: hinweis = "Zum Einladen brauchst du ein Squad, das einer deiner Charaktere führt." self.knopf_einladen.configure(state="disabled" if hinweis else "normal") self.einladen_hinweis.configure(text=hinweis) self._bild_zeigen(c) def _bild_zeigen(self, c): if not c["portraet"]: self.bild.configure(image="", text="kein\nPorträt", width=20, height=10) return schluessel = (c["id"], c.get("portraet_kennung")) if schluessel in self._bilder: foto = self._bilder[schluessel][1] self.bild.configure(image=foto, text="", width=foto.width(), height=foto.height()) return self.bild.configure(image="", text="lädt …", width=20, height=10) def fertig(daten): if not daten: return with Image.open(io.BytesIO(daten)) as bild: foto = ImageTk.PhotoImage(ImageOps.contain(bild.convert("RGBA"), (150, 190))) self._bilder[schluessel] = (daten, foto) aktuell = self._gewaehlter() if aktuell is not None and aktuell["id"] == c["id"]: self.bild.configure(image=foto, text="", width=foto.width(), height=foto.height()) self.hintergrund.starten(lambda: konto.bild(c["id"]), fertig, lambda f: None) def akte_ansehen(self): c = self._gewaehlter() if c is None: return def arbeit(): voll = konto.aufrufen("charakter_ansehen", id=c["id"])["charakter"] bild = konto.bild(c["id"]) if voll.get("portraet") else None return voll, bild self.hintergrund.starten(arbeit, lambda erg: akte_fenster(self, erg[0], erg[1]), lambda f: messagebox.showerror("Akte", fehlertext(f), parent=self)) def einladen(self): c = self._gewaehlter() gefuehrt = self._meine_gefuehrten_squads() if c is None or not gefuehrt: return if len(gefuehrt) == 1: self._einladen_in(gefuehrt[0], c) return menue = tk.Menu(self, tearoff=False) for squad in gefuehrt: menue.add_command(label=squad["name"], command=lambda s=squad: self._einladen_in(s, c)) knopf = self.knopf_einladen menue.tk_popup(knopf.winfo_rootx(), knopf.winfo_rooty() + knopf.winfo_height()) def _einladen_in(self, squad, c): self._aktion(lambda: konto.aufrufen("squad_einladen", squad_id=squad["id"], charakter_id=c["id"]), f"{charakter_name(c)} ist zu {squad['name']} eingeladen. Der Spieler muss annehmen.") # -- Squads ----------------------------------------------------------------------- def _gewaehltes_squad(self): auswahl = self.squad_liste.selection() return next((s for s in self.squads if str(s["id"]) == auswahl[0]), None) if auswahl else None def _squad_gewaehlt(self): s = self._gewaehltes_squad() if s is None: self.squad_titel.configure(text="Wähle ein Squad." if self.squads else "Noch keine Squads.") self.squad_beschreibung.configure(text="") self._ersetzen(self.mitglieder, []) else: self.squad_titel.configure(text=s["name"]) self.squad_beschreibung.configure(text=s.get("beschreibung") or "") # Der Fuehrer steht immer oben, die anderen in Reihenfolge des Beitritts mitglieder = sorted(s["mitglieder"], key=lambda m: m["id"] != s["fuehrer_id"]) self._ersetzen(self.mitglieder, [ (str(m["id"]), (("★ " if m["id"] == s["fuehrer_id"] else "") + charakter_name(m), m["rang"], zustand_text(m["status"]), m["spieler"]), tuple(t for t in (_zustand_tag(m["status"]), "eigener" if m["eigener"] else "") if t)) for m in mitglieder]) self._squad_knoepfe() def _gewaehltes_mitglied(self, squad): auswahl = self.mitglieder.selection() if squad is None or not auswahl: return None return next((m for m in squad["mitglieder"] if str(m["id"]) == auswahl[0]), None) def _squad_knoepfe(self): s = self._gewaehltes_squad() eigene = self._eigene_ids() fuehre = s is not None and s["fuehrer_id"] in eigene mitglied = self._gewaehltes_mitglied(s) fremdes_mitglied = mitglied is not None and mitglied["id"] != s["fuehrer_id"] mein_mitglied = s is not None and any(m["id"] in eigene and m["id"] != s["fuehrer_id"] for m in s["mitglieder"]) self.knopf_entfernen.configure(state="normal" if fuehre and fremdes_mitglied else "disabled") self.knopf_uebergeben.configure(state="normal" if fuehre and fremdes_mitglied else "disabled") self.knopf_aufloesen.configure(state="normal" if fuehre else "disabled") self.knopf_verlassen.configure(state="normal" if mein_mitglied or (fuehre and len(s["mitglieder"]) == 1) else "disabled") def squad_gruenden(self): frei = [c for c in self.charaktere if c["eigener"] and not c.get("squad")] if not frei: messagebox.showinfo("Squad gründen", "Du brauchst einen eigenen Charakter ohne Squad. Neue Akten erscheinen " "hier, sobald sie mit dem Server abgeglichen sind.", parent=self) return fenster = tk.Toplevel(self) fenster.title("Squad gründen") fenster.configure(bg=BG) fenster.resizable(False, False) fenster.transient(self.winfo_toplevel()) f = ttk.Frame(fenster, padding=18) f.pack(fill="both") ttk.Label(f, text="Name des Squads").grid(row=0, column=0, sticky="w", pady=5, padx=(0, 12)) name_var = tk.StringVar() name = ttk.Entry(f, textvariable=name_var, width=36) name.grid(row=0, column=1, sticky="ew", pady=5) ttk.Label(f, text="Geführt von").grid(row=1, column=0, sticky="w", pady=5, padx=(0, 12)) namen = [charakter_name(c) for c in frei] fuehrer_var = tk.StringVar(value=namen[0]) ttk.Combobox(f, textvariable=fuehrer_var, values=namen, state="readonly", width=34).grid( row=1, column=1, sticky="ew", pady=5) ttk.Label(f, text="Beschreibung").grid(row=2, column=0, sticky="nw", pady=5, padx=(0, 12)) beschreibung = tk.Text(f, width=36, height=4, **akte.TEXT_STIL) beschreibung.grid(row=2, column=1, sticky="ew", pady=5) def gruenden(): c = frei[namen.index(fuehrer_var.get())] text = beschreibung.get("1.0", "end-1c").strip() wert = name_var.get().strip() fenster.destroy() self._aktion(lambda: konto.aufrufen("squad_gruenden", charakter_id=c["id"], name=wert, beschreibung=text), f"Squad {wert} gegründet.") knoepfe = ttk.Frame(f) knoepfe.grid(row=3, column=0, columnspan=2, sticky="e", pady=(12, 0)) ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right") ttk.Button(knoepfe, text="Gründen", style="Accent.TButton", command=gruenden).pack(side="right", padx=(0, 8)) fenster.bind("", lambda e: fenster.destroy()) dialog_zentrieren(fenster, self) fenster.grab_set() name.focus_set() def mitglied_entfernen(self): s = self._gewaehltes_squad() m = self._gewaehltes_mitglied(s) if m and messagebox.askyesno("Entfernen", f"{charakter_name(m)} aus {s['name']} entfernen?", parent=self): self._aktion(lambda: konto.aufrufen("squad_entfernen", squad_id=s["id"], charakter_id=m["id"]), f"{charakter_name(m)} wurde entfernt.") def fuehrung_uebergeben(self): s = self._gewaehltes_squad() m = self._gewaehltes_mitglied(s) if m and messagebox.askyesno("Führung übergeben", f"Die Führung von {s['name']} an {charakter_name(m)} übergeben?", parent=self): self._aktion(lambda: konto.aufrufen("squad_fuehrung_uebergeben", squad_id=s["id"], charakter_id=m["id"]), f"{charakter_name(m)} führt jetzt {s['name']}.") def squad_verlassen(self): s = self._gewaehltes_squad() if s is None: return eigene = [m for m in s["mitglieder"] if m["eigener"]] # Wer allein fuehrt, verlaesst das Squad damit auch - es wird aufgeloest kandidaten = [m for m in eigene if m["id"] != s["fuehrer_id"]] or eigene if not kandidaten: return m = kandidaten[0] if messagebox.askyesno("Squad verlassen", f"{charakter_name(m)} verlässt {s['name']}?", parent=self): self._aktion(lambda: konto.aufrufen("squad_verlassen", charakter_id=m["id"]), f"{charakter_name(m)} hat {s['name']} verlassen.") def squad_aufloesen(self): s = self._gewaehltes_squad() if s and messagebox.askyesno("Squad auflösen", f"{s['name']} auflösen? Alle Mitglieder sind danach ohne Squad.", parent=self): self._aktion(lambda: konto.aufrufen("squad_aufloesen", squad_id=s["id"]), f"{s['name']} wurde aufgelöst.") # -- Einladungen ------------------------------------------------------------------ def einladung_beantworten(self, annehmen): auswahl = self.eingang.selection() if not auswahl: return e = next((x for x in self.einladungen["eingang"] if str(x["id"]) == auswahl[0]), None) if e is None: return squad = (e.get("squad") or {}).get("name", "das Squad") self._aktion(lambda: konto.aufrufen("einladung_beantworten", einladung_id=e["id"], annehmen=annehmen), f"Willkommen in {squad}." if annehmen else "Einladung abgelehnt.") def einladung_zurueckziehen(self): auswahl = self.ausgang.selection() if auswahl: self._aktion(lambda: konto.aufrufen("einladung_zurueckziehen", einladung_id=int(auswahl[0])), "Einladung zurückgezogen.") # -- Gemeinsam -------------------------------------------------------------------- def _aktion(self, arbeit, erfolg): self.status_var.set("Einen Moment …") def fertig(_): self.status_var.set(erfolg) self._laedt = False self.aktualisieren() def fehler(f): if isinstance(f, konto.ServerFehler) and f.code == "nicht_angemeldet": self._abgemeldet() return self.status_var.set("") messagebox.showerror("Squad", fehlertext(f), parent=self) self.aktualisieren() self.hintergrund.starten(arbeit, fertig, fehler)