squad-manager/squad.py
danny 4d9e30bc90 1.6.0: Squad-Reiter, Anmeldung und Abgleich im Programm
- Neuer Hauptreiter SQUAD: Anmeldung und Registrierung; angemeldet alle
  Charaktere mit Zustand (KIA/MIA/WIA), Suche und Fraktionsfilter,
  fremde Akten als Dokument, Squads gruenden und verwalten, Einladungen
  annehmen, ablehnen, zurueckziehen; Konto abmelden oder loeschen
- Akten werden nach dem Anmelden, kurz nach jeder Aenderung und alle
  5 Minuten mit dem Server abgeglichen; Zustand unter der Aktenliste
- Dokumentansicht als dokument_zeichnen() fuer eigene und fremde Akten;
  ohne Portraet scheint "KEIN PORTRAET" nicht mehr durch den Stempel
- Release-Bau: Bezeichner wie "konto_loeschen" bekommen keine Umlaute
  mehr - sonst waeren vier Serveraktionen im Paket kaputt gewesen
- Tests koennen mit SM_PROGRAMM gegen das gebaute Paket laufen
- Datenschutz-Baustein fuer tyrveil.com, Anleitung und Doku auf 1.6.0

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-13 20:09:31 +02:00

945 lines
43 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""
Hauptreiter SQUAD: Konto, alle Charaktere, Squads und Einladungen.
Ohne Anmeldung zeigt der Reiter die Anmeldung und Registrierung; alles
andere im Programm funktioniert auch ohne Konto. Angemeldet gibt es 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 = ("Angemeldet – Abgleich folgt", "aus") if konto.angemeldet() \
else ("Nicht angemeldet – Akten liegen nur auf diesem PC", "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("Die Anmeldung ist abgelaufen – bitte neu 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):
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=420, text=(
"Mit einem Konto liegen deine Akten sicher auf dem Server, du siehst die "
"Charaktere der anderen Spieler und kannst Squads bilden. Ohne Konto "
"funktioniert alles andere wie bisher.")).pack(anchor="w", pady=(4, 14))
reiter = ttk.Notebook(mitte)
reiter.pack(fill="x")
self.reiter = reiter
self._anmelden_aufbauen(reiter)
self._registrieren_aufbauen(reiter)
self.meldung_var = tk.StringVar()
self.meldung = ttk.Label(mitte, textvariable=self.meldung_var, wraplength=420, 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, pfad in (("Passwort vergessen?", None),
("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))
ziel = pfad or konto.webseite("/konto/vergessen.php")
verweis.bind("<Button-1>", 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 _anmelden_aufbauen(self, reiter):
f = ttk.Frame(reiter, padding=16)
reiter.add(f, text="Anmelden")
self.login_var, erstes = self._feld(f, 0, "Benutzername oder E-Mail")
self.passwort_var, pw = self._feld(f, 1, "Passwort", verdeckt=True)
knopf = ttk.Button(f, text="Anmelden", style="Accent.TButton", command=self.anmelden)
knopf.grid(row=2, column=1, sticky="e", pady=(10, 0))
self._knoepfe.append(knopf)
for eingabe in (erstes, pw):
eingabe.bind("<Return>", lambda e: self.anmelden())
self.erstes_feld = erstes
def _registrieren_aufbauen(self, reiter):
f = ttk.Frame(reiter, padding=16)
reiter.add(f, text="Registrieren")
self.neu_name_var, _ = self._feld(f, 0, "Benutzername")
self.neu_email_var, _ = self._feld(f, 1, "E-Mail")
self.neu_pw_var, _ = self._feld(f, 2, "Passwort (mind. 10 Zeichen)", verdeckt=True)
self.neu_pw2_var, letztes = self._feld(f, 3, "Passwort wiederholen", verdeckt=True)
letztes.bind("<Return>", lambda e: self.registrieren())
knopf = ttk.Button(f, text="Konto anlegen", style="Accent.TButton", command=self.registrieren)
knopf.grid(row=4, column=1, sticky="e", pady=(10, 0))
self._knoepfe.append(knopf)
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 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"))
def registrieren(self):
name, email = self.neu_name_var.get().strip(), self.neu_email_var.get().strip()
pw, pw2 = self.neu_pw_var.get(), self.neu_pw2_var.get()
if not name or not email or not pw:
self._zeigen("Bitte alle Felder ausfüllen.", "warnung")
return
if pw != pw2:
self._zeigen("Die beiden Passwörter stimmen nicht überein.", "warnung")
return
self._beschaeftigt(True)
self._zeigen("Lege Konto an …")
def fertig(antwort):
self._beschaeftigt(False)
self.neu_pw_var.set("")
self.neu_pw2_var.set("")
self.login_var.set(email)
self.reiter.select(0)
self._zeigen("Konto angelegt. Bitte bestätige den Link in der Mail an "
f"{email} – danach kannst du dich hier anmelden.", "ok")
def fehler(f):
self._beschaeftigt(False)
self._zeigen(fehlertext(f), "fehler")
self.hintergrund.starten(lambda: konto.registrieren(name, email, pw), fertig, 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("<Configure>", zeichnen)
leinwand.bind("<MouseWheel>", lambda e: leinwand.yview_scroll(int(-e.delta / 120), "units"))
fenster.bind("<Escape>", 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)
nutzer = konto.nutzer() or {}
self.nutzer_var.set(f"Angemeldet als {nutzer.get('benutzername', '?')}")
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())
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")
ttk.Label(f, text="Passwort zur Bestätigung").grid(row=1, column=0, sticky="w", pady=(14, 0), padx=(0, 12))
passwort = tk.StringVar()
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:
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("<Escape>", lambda e: fenster.destroy())
dialog_zentrieren(fenster, self)
fenster.grab_set()
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")
menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI,
activeforeground="#12150f", font=FONT_UI)
menue.add_command(label="Abmelden", command=self.abmelden)
menue.add_separator()
menue.add_command(label="Konto löschen …", command=self.konto_loeschen)
konto_menue["menu"] = menue
konto_menue.pack(side="right")
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._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("<Return>", 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("<<ComboboxSelected>>", lambda e: self.aktualisieren())
fraktion.bind("<MouseWheel>", 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("<<TreeviewSelect>>", lambda e: self._charakter_gewaehlt())
self.liste.bind("<Double-1>", 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("<<TreeviewSelect>>", 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("<<TreeviewSelect>>", 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():
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.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("<Escape>", 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)