squad-manager/squad_manager.py
danny a5da53d373 1.7.0: Mitmachen im Squad ohne Konto
Der Squad-Reiter braucht kein Konto mehr: Spielername eingeben, der PC
bekommt einen Schluessel (Token ohne Ablauf), die Akten werden fuer alle
sichtbar. E-Mail und Passwort sind optional ("Konto sichern") und machen
die Charaktere reset- und mehr-PC-fest. Ohne gesichertes Konto bietet das
Menue kein Abmelden, weil das den Schluessel loeschte.

Server: Aktionen mitmachen und konto_sichern, Konten ohne E-Mail
(Datenbank-Stand 2, eingespielt von DB::migrieren() bei der ersten
Anfrage), Loeschen ohne Passwort fuer reine Schluessel-Konten, Verwaltung
zeigt sie als "nur Schluessel". Deinstallationsfrage nennt den Schluessel.

Tests: Server 108, Zwei-PC 34, Oberflaeche 24 - auch gegen das Paket.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-15 06:35:54 +02:00

1566 lines
60 KiB
Python

"""
Squad Manager
Werkzeug fuer Squad. Kernfunktion: haelt die Sprechtaste automatisch
gedrueckt, solange gesprochen wird.
Greift nicht in Squad ein: kein Hook, keine DLL, kein Speicherzugriff.
Liest nur den Mikrofonpegel und ruft Windows SendInput / GetAsyncKeyState auf.
"""
import ctypes
import ctypes.wintypes as wintypes
import json
import os
import queue
import sys
import threading
import time
from pathlib import Path
def _ensure_tcl_paths():
"""
Muss vor dem tkinter-Import laufen.
Eine virtuelle Umgebung erbt unter Windows die Tcl/Tk-Pfade der
Basisinstallation nicht. tkinter findet dann init.tcl nicht und
bricht mit einem TclError ab. Hier werden die Pfade nachgezogen,
damit das Programm auch per Doppelklick oder Verknuepfung startet.
"""
if getattr(sys, "frozen", False):
return # gepackte EXE bringt Tcl/Tk selbst mit
tcl_root = Path(getattr(sys, "base_prefix", sys.prefix)) / "tcl"
if not tcl_root.is_dir():
return
for var, prefix, marker in (("TCL_LIBRARY", "tcl8", "init.tcl"),
("TK_LIBRARY", "tk8", "tk.tcl")):
if os.environ.get(var):
continue
for folder in sorted(tcl_root.glob(prefix + "*")):
if (folder / marker).is_file():
os.environ[var] = str(folder)
break
_ensure_tcl_paths()
import tkinter as tk # noqa: E402
from tkinter import ttk, messagebox # noqa: E402
import numpy as np # noqa: E402
import sounddevice as sd # noqa: E402
from theme import ( # noqa: E402
BG, PANEL, PANEL_HI, LINE, FG, FG_DIM, OLIVE, OLIVE_HI, AMBER,
AMBER_HELL, AMBER_DUNKEL, RED, GREEN_TX,
FONT_UI, FONT_BOLD, FONT_TITLE, FONT_MONO, FONT_STATUS,
apply_tactical_theme, LevelMeter,
)
import akte # noqa: E402
import squad # noqa: E402
import update_helfer # noqa: E402
APP_NAME = "Squad Manager"
VERSION = "1.7.0"
# Zaehlnummer fuer den Update-Vergleich, bei jedem Release um eins erhoehen.
# Seit 1.5.0 getrennt von der angezeigten Version: Die Anzeige sprang von
# 4.0 auf 1.5.0 zurueck, ein Vergleich der Anzeige haette danach nie wieder
# ein Update gefunden.
BUILD = 5
# Letzte Version aus der Zeit vor den Zaehlnummern
LETZTE_ALTE_VERSION = "4.0"
CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json"
LOG_PATH = CONFIG_PATH.parent / "error.log"
# Bis Version 3.2 hiess das Programm "Squad Voice Activation"
ALT_CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadVoiceActivation" / "config.json"
def alte_einstellungen_uebernehmen():
"""
Uebernimmt die Einstellungen aus der Zeit vor der Umbenennung.
Kopiert statt verschiebt: Eine noch vorhandene alte Installation soll
ihre Einstellungen behalten.
"""
if CONFIG_PATH.exists() or not ALT_CONFIG_PATH.exists():
return False
try:
import shutil
CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(ALT_CONFIG_PATH, CONFIG_PATH)
return True
except Exception:
return False
UPDATE_URL = "https://sva.tyrveil.com/version.json"
def version_tupel(text):
"""'3.10' wird zu (3, 10), damit 3.10 groesser ist als 3.9."""
teile = []
for stueck in str(text).strip().split("."):
ziffern = "".join(z for z in stueck if z.isdigit())
teile.append(int(ziffern) if ziffern else 0)
return tuple(teile)
def pruefe_update(timeout=6):
"""
Fragt die Versionsdatei auf dem Server ab.
Gibt die Angaben zurueck, wenn dort eine neuere Fassung steht, sonst
None. Netzwerkfehler sind kein Grund fuer eine Meldung - ohne
Internetverbindung laeuft das Programm ganz normal weiter.
"""
import json as _json
import urllib.request
if not UPDATE_URL.lower().startswith("https://"):
return None
try:
anfrage = urllib.request.Request(
UPDATE_URL, headers={"User-Agent": f"{APP_NAME}/{VERSION}"})
with urllib.request.urlopen(anfrage, timeout=timeout) as antwort:
angaben = _json.loads(antwort.read(65536).decode("utf-8"))
except Exception:
return None
# "anzeige" und "build" gibt es seit 1.5.0. "version" bleibt fuer die
# Programme bis 4.0 stehen, die nur dieses Feld kennen.
ziel = str(angaben.get("anzeige") or angaben.get("version", "")).strip()
datei = str(angaben.get("datei", "")).strip()
if not ziel or not datei.lower().startswith("https://"):
return None
if "build" in angaben:
try:
neuer = int(angaben["build"]) > BUILD
except (TypeError, ValueError):
return None
else:
neuer = version_tupel(ziel) > version_tupel(LETZTE_ALTE_VERSION)
if not neuer:
return None
installer = str(angaben.get("installer", "")).strip()
return {
"version": ziel,
"datei": datei,
"sha256": str(angaben.get("sha256", "")).strip().lower(),
"hinweis": str(angaben.get("hinweis", "")).strip()[:200],
"installer": installer if installer.lower().startswith("https://") else "",
}
def lade_update(angaben, ziel_pfad, fortschritt=None):
"""Laedt das Paket und prueft die Pruefsumme."""
import hashlib
import urllib.request
anfrage = urllib.request.Request(
angaben["datei"], headers={"User-Agent": f"{APP_NAME}/{VERSION}"})
hasher = hashlib.sha256()
geladen = 0
with urllib.request.urlopen(anfrage, timeout=30) as antwort:
gesamt = int(antwort.headers.get("Content-Length") or 0)
with open(ziel_pfad, "wb") as datei:
while True:
brocken = antwort.read(65536)
if not brocken:
break
datei.write(brocken)
hasher.update(brocken)
geladen += len(brocken)
if fortschritt and gesamt:
fortschritt(geladen, gesamt)
erwartet = angaben.get("sha256", "")
if erwartet and hasher.hexdigest() != erwartet:
raise ValueError(
"Die heruntergeladene Datei stimmt nicht mit der angegebenen "
"Pruefsumme ueberein und wurde verworfen.")
return ziel_pfad
def spiele_update_ein(zip_pfad, programm_ordner, installer_url=""):
"""
Entpackt das Paket und startet den Update-Helfer.
Das laufende Programm ersetzt seine Dateien nicht selbst. Das erledigt
update_helfer.py als eigener Prozess, sobald das Programm beendet ist,
und startet es danach neu. Bevorzugt wird der Helfer aus dem *neuen*
Paket: Eine Verbesserung am Helfer wirkt so schon bei dem Update, das
sie ausliefert. Seine Aufrufparameter sind deshalb eine Schnittstelle
und muessen zwischen den Versionen gleich bleiben.
"""
import shutil
import subprocess
import tempfile
import zipfile
arbeit = Path(tempfile.mkdtemp(prefix="sm_update_"))
with zipfile.ZipFile(zip_pfad) as archiv:
archiv.extractall(arbeit)
quelle = arbeit / "Programm"
if not quelle.is_dir():
treffer = list(arbeit.rglob("squad_manager.py"))
if not treffer:
raise ValueError("Im Paket wurde kein Programmordner gefunden.")
quelle = treffer[0].parent
kandidaten = (quelle / "update_helfer.py",
Path(__file__).resolve().parent / "update_helfer.py")
helfer = next((p for p in kandidaten if p.is_file()), None)
if helfer is None:
raise ValueError("Der Update-Helfer fehlt.")
# Ausserhalb von quelle, damit er beim Kopieren nicht mitten im Lauf liegt
ausfuehren = arbeit / "update_helfer.py"
shutil.copy2(helfer, ausfuehren)
subprocess.Popen([sys.executable, str(ausfuehren), str(quelle),
str(programm_ordner), str(os.getpid()), installer_url],
creationflags=0x08000000) # kein Konsolenfenster
return True
def log_exception(exc_type, exc, tb):
"""Schreibt einen Fehler ins Log. Ohne Konsolenfenster geht er sonst verloren."""
import traceback
text = "".join(traceback.format_exception(exc_type, exc, tb))
try:
LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
with open(LOG_PATH, "a", encoding="utf-8") as fh:
fh.write(f"\n--- {time.strftime('%Y-%m-%d %H:%M:%S')} ---\n{text}")
except Exception:
pass
return text
# ---------------------------------------------------------------------------
# Win32
# ---------------------------------------------------------------------------
user32 = ctypes.WinDLL("user32", use_last_error=True)
kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
# Der laufende Prozess heisst SquadGame-Win64-Shipping.exe, der Launcher
# SquadGame.exe. Verglichen wird per Praefix, damit beide passen - und
# damit dieses Programm selbst nicht versehentlich als Squad zaehlt.
SQUAD_PROCESS_DEFAULT = "SquadGame"
INPUT_MOUSE = 0
INPUT_KEYBOARD = 1
KEYEVENTF_KEYUP = 0x0002
MOUSEEVENTF_MIDDLEDOWN = 0x0020
MOUSEEVENTF_MIDDLEUP = 0x0040
MOUSEEVENTF_XDOWN = 0x0080
MOUSEEVENTF_XUP = 0x0100
CURSOR_SHOWING = 0x0001
# ULONG_PTR ist zeigergross: 64 Bit auf 64-Bit-Windows
ULONG_PTR = wintypes.WPARAM
class KEYBDINPUT(ctypes.Structure):
_fields_ = [
("wVk", wintypes.WORD),
("wScan", wintypes.WORD),
("dwFlags", wintypes.DWORD),
("time", wintypes.DWORD),
("dwExtraInfo", ULONG_PTR),
]
class MOUSEINPUT(ctypes.Structure):
_fields_ = [
("dx", wintypes.LONG),
("dy", wintypes.LONG),
("mouseData", wintypes.DWORD),
("dwFlags", wintypes.DWORD),
("time", wintypes.DWORD),
("dwExtraInfo", ULONG_PTR),
]
class HARDWAREINPUT(ctypes.Structure):
_fields_ = [
("uMsg", wintypes.DWORD),
("wParamL", wintypes.WORD),
("wParamH", wintypes.WORD),
]
class _INPUTUNION(ctypes.Union):
_fields_ = [("ki", KEYBDINPUT), ("mi", MOUSEINPUT), ("hi", HARDWAREINPUT)]
class INPUT(ctypes.Structure):
_anonymous_ = ("u",)
_fields_ = [("type", wintypes.DWORD), ("u", _INPUTUNION)]
class POINT(ctypes.Structure):
_fields_ = [("x", wintypes.LONG), ("y", wintypes.LONG)]
class CURSORINFO(ctypes.Structure):
_fields_ = [
("cbSize", wintypes.DWORD),
("flags", wintypes.DWORD),
("hCursor", wintypes.HANDLE),
("ptScreenPos", POINT),
]
user32.SendInput.argtypes = (wintypes.UINT, ctypes.POINTER(INPUT), ctypes.c_int)
user32.SendInput.restype = wintypes.UINT
user32.GetAsyncKeyState.argtypes = (ctypes.c_int,)
user32.GetAsyncKeyState.restype = ctypes.c_short
user32.GetCursorInfo.argtypes = (ctypes.POINTER(CURSORINFO),)
user32.GetCursorInfo.restype = wintypes.BOOL
user32.GetWindowThreadProcessId.argtypes = (wintypes.HWND, ctypes.POINTER(wintypes.DWORD))
user32.GetWindowThreadProcessId.restype = wintypes.DWORD
kernel32.OpenProcess.argtypes = (wintypes.DWORD, wintypes.BOOL, wintypes.DWORD)
kernel32.OpenProcess.restype = wintypes.HANDLE
kernel32.QueryFullProcessImageNameW.argtypes = (
wintypes.HANDLE, wintypes.DWORD, wintypes.LPWSTR, ctypes.POINTER(wintypes.DWORD))
kernel32.QueryFullProcessImageNameW.restype = wintypes.BOOL
kernel32.CloseHandle.argtypes = (wintypes.HANDLE,)
kernel32.CloseHandle.restype = wintypes.BOOL
# ---------------------------------------------------------------------------
# Tastentabelle: Anzeigename -> (art, code)
# art "key" -> code ist ein Virtual-Key-Code
# art "mouse" -> code ist die XBUTTON-Nummer (3 = mittlere Maustaste)
# ---------------------------------------------------------------------------
VK_MBUTTON, VK_XBUTTON1, VK_XBUTTON2 = 0x04, 0x05, 0x06
KEYS = {}
for _c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
KEYS[_c] = ("key", ord(_c))
for _n in range(10):
KEYS[str(_n)] = ("key", 0x30 + _n)
for _i in range(1, 13):
KEYS[f"F{_i}"] = ("key", 0x6F + _i)
KEYS.update({
"Maus mitte": ("mouse", 3),
"Maus 4": ("mouse", 1),
"Maus 5": ("mouse", 2),
"Pause": ("key", 0x13),
"Rollen": ("key", 0x91),
"Einfg": ("key", 0x2D),
"Entf": ("key", 0x2E),
"Pos1": ("key", 0x24),
"Ende": ("key", 0x23),
"Bild auf": ("key", 0x21),
"Bild ab": ("key", 0x22),
})
KEY_NAMES = list(KEYS.keys())
NONE_LABEL = "(keine)"
NO_MOD_LABEL = "(kein)"
# Zusatztasten fuer Kombinationen wie Strg+V (Squad "Direct Voice" o. ae.)
MODIFIERS = {
NO_MOD_LABEL: None,
"Strg": 0x11, # VK_CONTROL
"Alt": 0x12, # VK_MENU
"Shift": 0x10, # VK_SHIFT
}
MOD_NAMES = list(MODIFIERS.keys())
def _async_vk(name):
"""Virtual-Key-Code, mit dem GetAsyncKeyState diese Taste abgefragt wird."""
kind, code = KEYS[name]
if kind == "key":
return code
return {1: VK_XBUTTON1, 2: VK_XBUTTON2, 3: VK_MBUTTON}[code]
def is_physically_down(name):
"""True, wenn die Taste gerade gedrueckt ist (egal ob echt oder simuliert)."""
if name not in KEYS:
return False
return bool(user32.GetAsyncKeyState(_async_vk(name)) & 0x8000)
def is_binding_down(mod, name):
"""True, wenn Taste und ggf. zugehoerige Zusatztaste gleichzeitig gehalten werden."""
if name not in KEYS:
return False
mod_vk = MODIFIERS.get(mod)
if mod_vk is not None and not (user32.GetAsyncKeyState(mod_vk) & 0x8000):
return False
return is_physically_down(name)
def _send(kind, **fields):
if kind == "key":
inp = INPUT(type=INPUT_KEYBOARD, ki=KEYBDINPUT(**fields))
else:
inp = INPUT(type=INPUT_MOUSE, mi=MOUSEINPUT(**fields))
sent = user32.SendInput(1, ctypes.byref(inp), ctypes.sizeof(INPUT))
if sent != 1:
err = ctypes.get_last_error()
raise OSError(err, f"SendInput fehlgeschlagen (sent={sent}, error={err})")
def send_input_key(name, down):
"""Drueckt bzw. loesst die benannte Taste."""
kind, code = KEYS[name]
if kind == "key":
_send("key", wVk=code, wScan=0,
dwFlags=0 if down else KEYEVENTF_KEYUP, time=0, dwExtraInfo=0)
elif code == 3:
_send("mouse", dx=0, dy=0, mouseData=0,
dwFlags=MOUSEEVENTF_MIDDLEDOWN if down else MOUSEEVENTF_MIDDLEUP,
time=0, dwExtraInfo=0)
else:
_send("mouse", dx=0, dy=0, mouseData=code,
dwFlags=MOUSEEVENTF_XDOWN if down else MOUSEEVENTF_XUP,
time=0, dwExtraInfo=0)
def send_modifier(mod, down):
vk = MODIFIERS.get(mod)
if vk is None:
return
_send("key", wVk=vk, wScan=0,
dwFlags=0 if down else KEYEVENTF_KEYUP, time=0, dwExtraInfo=0)
def send_binding(mod, name, down):
"""Drueckt bzw. loesst eine Kombination. Zusatztaste zuerst rein, zuletzt raus."""
if down:
send_modifier(mod, True)
send_input_key(name, True)
else:
send_input_key(name, False)
send_modifier(mod, False)
def get_foreground_process_name():
"""Dateiname des Prozesses, dem das aktive Fenster gehoert (z. B. SquadGame.exe)."""
hwnd = user32.GetForegroundWindow()
if not hwnd:
return ""
pid = wintypes.DWORD()
user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
if not pid.value:
return ""
handle = kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid.value)
if not handle:
return ""
try:
size = wintypes.DWORD(1024)
buf = ctypes.create_unicode_buffer(size.value)
if kernel32.QueryFullProcessImageNameW(handle, 0, buf, ctypes.byref(size)):
return os.path.basename(buf.value)
return ""
finally:
kernel32.CloseHandle(handle)
def set_dark_titlebar(root):
"""
Faerbt die Fenstertitelleiste dunkel.
Windows zeichnet die Titelleiste sonst hell, was ueber der dunklen
Oberflaeche wie ein weisser Balken wirkt. Das Attribut heisst auf
aktuellen Windows-Versionen 20, auf aelteren 19.
"""
try:
root.update_idletasks()
hwnd = user32.GetParent(root.winfo_id()) or root.winfo_id()
dwm = ctypes.WinDLL("dwmapi")
an = ctypes.c_int(1)
for attribut in (20, 19):
if dwm.DwmSetWindowAttribute(
wintypes.HWND(hwnd), ctypes.c_uint(attribut),
ctypes.byref(an), ctypes.sizeof(an)) == 0:
# Neu zeichnen erzwingen, sonst bleibt die alte Farbe stehen
root.withdraw()
root.deiconify()
return True
except Exception:
pass
return False
def set_window_icon(root):
"""
Setzt das Programmsymbol fuer Fenster und Taskleiste.
Verwendet icon.ico neben dem Programm. Fehlt sie, bleibt das
Standardsymbol - ein fehlendes Symbol ist kein Grund abzubrechen.
"""
ordner = Path(__file__).resolve().parent
ico = ordner / "icon.ico"
if ico.exists():
try:
root.iconbitmap(default=str(ico))
return True
except Exception:
pass
png = ordner / "icon.png"
if png.exists():
try:
bild = tk.PhotoImage(file=str(png))
root.iconphoto(True, bild)
root._icon_ref = bild # Verweis halten, sonst weggeraeumt
return True
except Exception:
pass
return False
def clean_device_name(name):
"""
Macht Windows-Geraetenamen lesbar.
Manche Treiber liefern einen unaufgeloesten Ressourcenverweis wie
"@System32\\drivers\\bthhfenum.sys,#4;%1 Hands-Free HF Audio%0 ;(iPhone)".
Daraus wird "Hands-Free HF Audio (iPhone)".
"""
name = name.replace("\r", " ").replace("\n", " ")
if name.lstrip().startswith("@") or ".sys," in name or ".dll," in name:
pieces = []
for piece in name.split(";")[1:]:
piece = piece.strip()
if piece.startswith("%1"):
piece = piece[2:].strip()
if piece.endswith("%0"):
piece = piece[:-2].strip()
piece = piece.strip(" ()")
if piece:
pieces.append(piece)
if pieces:
name = f"{pieces[0]} ({', '.join(pieces[1:])})" if len(pieces) > 1 else pieces[0]
return " ".join(name.split())
API_RANG = {"WASAPI": 0, "DirectSound": 1, "MME": 2, "WDM-KS": 3}
# Platzhalter fuer "Windows-Standardgeraet" - kein echtes Mikrofon
ALIAS_GERAETE = ("microsoft soundmapper", "primärer soundaufnahmetreiber",
"primarer soundaufnahmetreiber", "primary sound capture")
def _vergleichsname(name):
return "".join(z for z in name.lower() if z.isalnum())
def gleiches_geraet(a, b):
"""
Zwei Eintraege gehoeren zum selben Mikrofon.
Die MME-Schnittstelle kuerzt Geraetenamen auf 31 Zeichen, deshalb wird
geprueft, ob der kuerzere Name Anfang des laengeren ist.
"""
x, y = _vergleichsname(a), _vergleichsname(b)
if x == y:
return True
kurz, lang = (x, y) if len(x) <= len(y) else (y, x)
return len(kurz) >= 8 and lang.startswith(kurz)
def zusammenfassen(geraete):
"""Pro Mikrofon nur den Eintrag mit der besten Schnittstelle behalten."""
gruppen = []
for geraet in sorted(geraete, key=lambda g: len(_vergleichsname(g["name"]))):
for gruppe in gruppen:
if gleiches_geraet(gruppe[0]["name"], geraet["name"]):
gruppe.append(geraet)
break
else:
gruppen.append([geraet])
return [min(g, key=lambda d: API_RANG.get(d["api"], 9)) for g in gruppen]
def enumerate_inputs(rescan=False, alle=False):
"""
Alle Eingabegeraete mit Host-API und nativer Abtastrate.
Die Geraeteindizes von PortAudio sind nicht stabil - sie verschieben
sich, sobald ein Treiber dazukommt oder verschwindet. Deshalb wird
ueberall mit dem Label gearbeitet und der Index erst unmittelbar vor
dem Oeffnen aufgeloest.
"""
if rescan:
try:
sd._terminate()
sd._initialize()
except Exception:
pass
apis = sd.query_hostapis()
result = []
for index, dev in enumerate(sd.query_devices()):
if dev["max_input_channels"] < 1:
continue
api = apis[dev["hostapi"]]["name"].replace("Windows ", "")
name = clean_device_name(dev["name"])
result.append({
"index": index,
"name": name,
"api": api,
"samplerate": int(dev["default_samplerate"]),
"label": f"[{api}] {name}",
})
if alle:
return result
gefiltert = [d for d in result
if not any(a in d["name"].lower() for a in ALIAS_GERAETE)]
# WDM-KS ist der Kernel-Zugang. Dort taucht zusaetzlich zu jedem echten
# Mikrofon ein Eintrag unter abweichendem Treibernamen auf, dazu Geraete,
# die in Windows gar nicht aktiv sind. Sobald WASAPI etwas liefert, ist
# das die massgebliche Liste - sie entspricht den Windows-Soundeinstellungen.
ohne_kernel = [d for d in gefiltert if d["api"] != "WDM-KS"]
if any(d["api"] == "WASAPI" for d in ohne_kernel):
gefiltert = ohne_kernel
return zusammenfassen(gefiltert or result)
def pick_samplerate(index, preferred):
"""Erste Abtastrate, die das Geraet tatsaechlich akzeptiert."""
seen = []
for rate in (preferred, 48000, 44100, 16000):
if rate in seen:
continue
seen.append(rate)
try:
sd.check_input_settings(device=index, channels=1,
samplerate=rate, dtype="float32")
return rate
except Exception:
continue
return None
def audio_service_running():
"""
Laeuft der Windows-Audiodienst? Stuerzt er ab, scheitert jede Aufnahme.
Nur lesender Zugriff auf den Dienststatus.
"""
SC_MANAGER_CONNECT, SERVICE_QUERY_STATUS, SERVICE_RUNNING = 0x0001, 0x0004, 0x0004
advapi = ctypes.WinDLL("advapi32", use_last_error=True)
class SERVICE_STATUS(ctypes.Structure):
_fields_ = [("dwServiceType", wintypes.DWORD),
("dwCurrentState", wintypes.DWORD),
("dwControlsAccepted", wintypes.DWORD),
("dwWin32ExitCode", wintypes.DWORD),
("dwServiceSpecificExitCode", wintypes.DWORD),
("dwCheckPoint", wintypes.DWORD),
("dwWaitHint", wintypes.DWORD)]
manager = advapi.OpenSCManagerW(None, None, SC_MANAGER_CONNECT)
if not manager:
return True # Status nicht ermittelbar - nicht faelschlich warnen
try:
service = advapi.OpenServiceW(manager, "Audiosrv", SERVICE_QUERY_STATUS)
if not service:
return True
try:
status = SERVICE_STATUS()
if not advapi.QueryServiceStatus(service, ctypes.byref(status)):
return True
return status.dwCurrentState == SERVICE_RUNNING
finally:
advapi.CloseServiceHandle(service)
finally:
advapi.CloseServiceHandle(manager)
def beep(enabled):
"""Kurze Rueckmeldung zum Hotkey - im Vollbild ist das Fenster nicht sichtbar."""
def run():
try:
import winsound
winsound.Beep(880 if enabled else 440, 90)
except Exception:
pass
threading.Thread(target=run, daemon=True).start()
def cursor_is_visible():
"""
True, wenn Windows gerade einen Mauszeiger zeichnet.
Squad blendet den Zeiger im Spiel aus und im Deploy-/Menuebildschirm ein.
Damit laesst sich der Respawn-Screen erkennen, ohne das Spiel anzufassen.
"""
info = CURSORINFO()
info.cbSize = ctypes.sizeof(CURSORINFO)
if not user32.GetCursorInfo(ctypes.byref(info)):
return True
return bool(info.flags & CURSOR_SHOWING)
# ---------------------------------------------------------------------------
# Anwendung
# ---------------------------------------------------------------------------
class VoiceActivationApp:
POLL_SECONDS = 0.02
def __init__(self, root):
self.root = root
self.root.title(f"{APP_NAME} {VERSION}")
self.root.geometry("900x830")
self.root.minsize(780, 520)
set_window_icon(self.root)
set_dark_titlebar(self.root)
self.audio_queue = queue.Queue(maxsize=10)
self.running = False
self.stream = None
self.ptt_down = False
self.active_binding = None
self.last_voice_time = 0.0
self.current_level = 0.0
self.hold_reason = ""
self.hotkey_was_down = False
self.device_var = tk.StringVar()
self.threshold_var = tk.DoubleVar(value=0.025)
self.release_ms_var = tk.IntVar(value=450)
self.ptt_key_var = tk.StringVar(value="V")
self.ptt_mod_var = tk.StringVar(value=NO_MOD_LABEL)
self.radio1_var = tk.StringVar(value="B")
self.radio1_mod_var = tk.StringVar(value=NO_MOD_LABEL)
self.radio2_var = tk.StringVar(value="G")
self.radio2_mod_var = tk.StringVar(value=NO_MOD_LABEL)
self.radio3_var = tk.StringVar(value=NONE_LABEL)
self.radio3_mod_var = tk.StringVar(value=NO_MOD_LABEL)
self.hotkey_var = tk.StringVar(value="Pause")
self.squad_process_var = tk.StringVar(value=SQUAD_PROCESS_DEFAULT)
self.squad_only_var = tk.BooleanVar(value=True)
self.pause_on_cursor_var = tk.BooleanVar(value=False)
self.beep_var = tk.BooleanVar(value=True)
self.alle_geraete_var = tk.BooleanVar(value=False)
self.enabled_var = tk.BooleanVar(value=True)
self.status_var = tk.StringVar(value="Gestoppt")
self.detail_var = tk.StringVar(value="")
self.device_info_var = tk.StringVar(value="")
self.diag_var = tk.StringVar(value="")
self.inputs = []
self.worker = None
self.update_angaben = None
self.build_ui()
self.refresh_devices()
self.load_config()
self.arm_autosave()
self.root.protocol("WM_DELETE_WINDOW", self.on_close)
self.root.report_callback_exception = self.on_tk_error
self.root.after(80, self.ui_tick)
self.root.after(1500, self.suche_update)
def on_tk_error(self, exc_type, exc, tb):
"""Fehler aus Tk-Callbacks sichtbar machen statt still verschlucken."""
log_exception(exc_type, exc, tb)
try:
messagebox.showerror(
APP_NAME,
f"Unerwarteter Fehler:\n\n{exc_type.__name__}: {exc}\n\n"
f"Einzelheiten stehen in:\n{LOG_PATH}")
except Exception:
pass
# -- UI -----------------------------------------------------------------
def build_ui(self):
header = ttk.Frame(self.root)
header.pack(fill="x", padx=18, pady=(16, 4))
ttk.Label(header, text="SQUAD MANAGER",
style="Title.TLabel").pack(anchor="w")
ttk.Label(header, style="Sub.TLabel",
text="Sprachaktivierung, Personalakten und Squads.").pack(anchor="w")
ttk.Separator(self.root, orient="horizontal").pack(
fill="x", padx=18, pady=(10, 0))
# Die Leiste mit Starten/Stoppen wird VOR dem Notebook gepackt und am
# unteren Rand verankert. Sonst frisst das Notebook (expand=True) den
# Platz und die Knoepfe fallen aus dem Fenster.
self._build_statusbar()
self._build_update_banner()
# Hauptreiter je Modul. Die Statusleiste bleibt darunter fuer alle
# Module sichtbar - die Sprachaktivierung laeuft weiter, waehrend man
# zum Beispiel an einer Akte schreibt.
haupt = ttk.Notebook(self.root, style="Haupt.TNotebook")
self.haupt_nb = haupt
haupt.pack(fill="both", expand=True, padx=16, pady=(4, 8))
seite_funk = ttk.Frame(haupt)
seite_akte = ttk.Frame(haupt)
seite_squad = ttk.Frame(haupt)
haupt.add(seite_funk, text="FUNK")
haupt.add(seite_akte, text="AKTE")
haupt.add(seite_squad, text="SQUAD")
nb = ttk.Notebook(seite_funk)
self.nb = nb
nb.pack(fill="both", expand=True, pady=(6, 0))
tab_main = ttk.Frame(nb)
tab_keys = ttk.Frame(nb)
nb.add(tab_main, text=" Mikrofon ")
nb.add(tab_keys, text=" Tasten und Verhalten ")
self._build_main_tab(tab_main)
self._build_keys_tab(tab_keys)
self.akte = akte.AkteSeite(seite_akte)
self.akte.pack(fill="both", expand=True)
self.squad = squad.SquadSeite(seite_squad, self.akte, log_exception)
self.squad.pack(fill="both", expand=True)
haupt.bind("<<NotebookTabChanged>>", lambda e: self.squad.sichtbar()
if haupt.index("current") == 2 else None, add="+")
def _build_main_tab(self, parent):
f = ttk.Frame(parent)
f.pack(fill="both", expand=True, padx=12, pady=12)
f.columnconfigure(1, weight=1)
ttk.Label(f, text="Mikrofon").grid(row=0, column=0, sticky="w", pady=8)
self.device_combo = ttk.Combobox(f, textvariable=self.device_var,
state="readonly", width=44)
self.device_combo.grid(row=0, column=1, sticky="ew", padx=8, pady=8)
ttk.Button(f, text="Neu laden",
command=lambda: self.refresh_devices(rescan=True)).grid(
row=0, column=2, pady=8)
ttk.Checkbutton(
f, variable=self.alle_geraete_var,
text="Jede Windows-Schnittstelle einzeln auflisten",
command=lambda: self.refresh_devices(rescan=False),
).grid(row=1, column=1, sticky="w", padx=8, pady=(0, 6))
ttk.Label(f, text="Schwelle").grid(row=2, column=0, sticky="w", pady=8)
ttk.Scale(f, from_=0.002, to=0.100, variable=self.threshold_var,
orient="horizontal").grid(row=2, column=1, sticky="ew", padx=8, pady=8)
self.threshold_label = ttk.Label(f, text="0.025", width=8)
self.threshold_label.grid(row=2, column=2, sticky="w", pady=8)
ttk.Label(f, text="Pegel").grid(row=3, column=0, sticky="w", pady=8)
self.level_bar = LevelMeter(f)
self.level_bar.grid(row=3, column=1, sticky="ew", padx=8, pady=8)
self.level_label = ttk.Label(f, text="0.000", width=8, style="Mono.TLabel")
self.level_label.grid(row=3, column=2, sticky="w", pady=8)
ttk.Label(f, text="Nachlaufzeit").grid(row=4, column=0, sticky="w", pady=8)
row3 = ttk.Frame(f)
row3.grid(row=4, column=1, sticky="w", padx=8, pady=8)
ttk.Spinbox(row3, from_=100, to=2000, increment=50,
textvariable=self.release_ms_var, width=8).pack(side="left")
ttk.Label(row3, text="ms nach dem letzten Wort").pack(side="left", padx=8)
diag = ttk.LabelFrame(f, text="Warum sendet es (nicht)?")
diag.grid(row=5, column=0, columnspan=3, sticky="ew", pady=(16, 8))
ttk.Label(diag, textvariable=self.diag_var, justify="left",
font=("Consolas", 9)).pack(anchor="w", padx=10, pady=8)
ttk.Label(diag, textvariable=self.device_info_var,
foreground="#666").pack(anchor="w", padx=10, pady=(0, 8))
box = ttk.LabelFrame(f, text="Eingabetest")
box.grid(row=6, column=0, columnspan=3, sticky="ew", pady=(8, 8))
ttk.Button(box, text="PTT-Taste testen (1 Sekunde halten)",
command=self.test_ptt).pack(side="left", padx=10, pady=10)
self.test_result = ttk.Label(box, text="Vor dem Start von Squad ausprobieren.")
self.test_result.pack(side="left", padx=10, pady=10)
ttk.Label(f, justify="left", text=(
"Notepad oeffnen, hineinklicken, zurueck zu diesem Fenster wechseln\n"
"und den Test starten. Erscheint die Taste in Notepad, funktioniert\n"
"die Eingabesimulation. Laeuft Squad als Administrator, muss auch\n"
"dieses Programm als Administrator laufen.")
).grid(row=7, column=0, columnspan=3, sticky="w", pady=(4, 0))
def _build_keys_tab(self, parent):
f = ttk.Frame(parent)
f.pack(fill="both", expand=True, padx=12, pady=12)
f.columnconfigure(2, weight=1)
ttk.Label(f, text="Sprechtaste (wird automatisch gehalten)").grid(
row=0, column=0, sticky="w", pady=8)
ptt_row = ttk.Frame(f)
ptt_row.grid(row=0, column=1, columnspan=2, sticky="w", padx=8, pady=8)
ttk.Combobox(ptt_row, textvariable=self.ptt_mod_var, values=MOD_NAMES,
state="readonly", width=8).pack(side="left")
ttk.Label(ptt_row, text="+").pack(side="left", padx=6)
ttk.Combobox(ptt_row, textvariable=self.ptt_key_var, values=KEY_NAMES,
state="readonly", width=12).pack(side="left")
ttk.Label(ptt_row, text=" z. B. Local V oder Fireteam-Kanal",
foreground="#666").pack(side="left", padx=6)
box = ttk.LabelFrame(
f, text="Andere Sprechtasten - Automatik pausiert, solange eine gehalten wird")
box.grid(row=1, column=0, columnspan=3, sticky="ew", pady=(16, 8))
for i, (label, mod_var, key_var, hint) in enumerate([
("Squad Radio", self.radio1_mod_var, self.radio1_var, "meist B"),
("Command Radio", self.radio2_mod_var, self.radio2_var, "meist G"),
("Weitere Taste", self.radio3_mod_var, self.radio3_var, "optional"),
]):
ttk.Label(box, text=label).grid(row=i, column=0, sticky="w", padx=10, pady=6)
ttk.Combobox(box, textvariable=mod_var, values=MOD_NAMES,
state="readonly", width=8).grid(row=i, column=1, padx=(10, 2), pady=6)
ttk.Label(box, text="+").grid(row=i, column=2)
ttk.Combobox(box, textvariable=key_var, values=[NONE_LABEL] + KEY_NAMES,
state="readonly", width=12).grid(row=i, column=3, padx=(2, 10), pady=6)
ttk.Label(box, text=hint, foreground="#666").grid(row=i, column=4,
sticky="w", padx=6)
ttk.Label(f, justify="left", text=(
"Drueckst du selbst eine dieser Tasten, laesst das Programm die\n"
"Local-Taste sofort los und haelt sich raus, bis du sie wieder\n"
"loslaesst. Dein Funkspruch wird dadurch nicht mehr ueberschrieben.")
).grid(row=2, column=0, columnspan=3, sticky="w", pady=(0, 12))
box2 = ttk.LabelFrame(f, text="Verhalten")
box2.grid(row=3, column=0, columnspan=3, sticky="ew", pady=8)
ttk.Checkbutton(
box2, variable=self.squad_only_var,
text="Alles nur aktiv, solange dieses Programm im Vordergrund ist:",
).pack(anchor="w", padx=10, pady=(8, 2))
proc_row = ttk.Frame(box2)
proc_row.pack(anchor="w", padx=32, pady=(0, 4))
ttk.Entry(proc_row, textvariable=self.squad_process_var, width=22).pack(side="left")
self.proc_hint = ttk.Label(proc_row, foreground="#666", text="")
self.proc_hint.pack(side="left", padx=10)
ttk.Checkbutton(
box2, variable=self.pause_on_cursor_var,
text="Pausieren, solange ein Mauszeiger sichtbar ist (Deploy-Screen, Menue, Karte)",
).pack(anchor="w", padx=10, pady=4)
self.cursor_hint = ttk.Label(box2, foreground="#666", text="")
self.cursor_hint.pack(anchor="w", padx=32, pady=(0, 8))
row = ttk.Frame(box2)
row.pack(anchor="w", padx=10, pady=(4, 2))
ttk.Label(row, text="Stummschalt-Hotkey (nur im Spiel)").pack(side="left")
ttk.Combobox(row, textvariable=self.hotkey_var, values=[NONE_LABEL] + KEY_NAMES,
state="readonly", width=14).pack(side="left", padx=10)
ttk.Checkbutton(
box2, variable=self.beep_var,
text="Signalton beim Umschalten (hoch = aktiv, tief = stumm)",
).pack(anchor="w", padx=32, pady=(0, 10))
ttk.Label(f, text="Alle Aenderungen werden sofort gespeichert.",
style="Dim.TLabel").grid(row=4, column=0, columnspan=2,
sticky="w", pady=(16, 0))
self.save_hint = ttk.Label(f, style="Dim.TLabel", text="")
self.save_hint.grid(row=5, column=0, columnspan=3, sticky="w", pady=(2, 0))
def _build_update_banner(self):
"""Hinweisleiste auf eine neue Fassung. Bleibt verborgen, bis es eine gibt."""
self.update_banner = tk.Frame(self.root, bg=AMBER_DUNKEL,
highlightthickness=1,
highlightbackground=AMBER)
innen = tk.Frame(self.update_banner, bg=AMBER_DUNKEL)
innen.pack(fill="x", padx=14, pady=9)
self.update_text_var = tk.StringVar(value="")
tk.Label(innen, textvariable=self.update_text_var, bg=AMBER_DUNKEL,
fg=AMBER, font=FONT_BOLD, anchor="w",
justify="left").pack(side="left", fill="x", expand=True)
tk.Button(innen, text="Später", command=self.update_verbergen,
bg=AMBER_DUNKEL, fg=FG_DIM, activebackground=PANEL_HI,
activeforeground=FG, relief="flat", bd=0, padx=12, pady=4,
font=FONT_UI, cursor="hand2").pack(side="right", padx=(8, 0))
self.update_btn = tk.Button(
innen, text="Jetzt aktualisieren", command=self.update_starten,
bg=AMBER, fg="#1a1508", activebackground=AMBER_HELL,
activeforeground="#1a1508", relief="flat", bd=0, padx=16, pady=4,
font=FONT_BOLD, cursor="hand2")
self.update_btn.pack(side="right")
def _build_statusbar(self):
self.status_trenner = ttk.Separator(self.root, orient="horizontal")
self.status_trenner.pack(side="bottom", fill="x", padx=0, pady=(0, 0))
bar = ttk.Frame(self.root)
bar.pack(side="bottom", fill="x", padx=16, pady=12)
self.start_btn = ttk.Button(bar, text="STARTEN", style="Accent.TButton",
command=self.start)
self.start_btn.pack(side="left")
self.stop_btn = ttk.Button(bar, text="STOPPEN", command=self.stop,
state="disabled")
self.stop_btn.pack(side="left", padx=8)
right = ttk.Frame(bar)
right.pack(side="right")
ttk.Label(right, textvariable=self.detail_var,
style="Dim.TLabel").pack(side="left", padx=10)
self.status_label = ttk.Label(right, textvariable=self.status_var,
font=FONT_STATUS, foreground=FG_DIM)
self.status_label.pack(side="left")
# -- Konfiguration ------------------------------------------------------
def config_dict(self):
return {
"device": self.device_var.get(),
"threshold": round(float(self.threshold_var.get()), 4),
"release_ms": int(self.release_ms_var.get()),
"ptt_key": self.ptt_key_var.get(),
"ptt_mod": self.ptt_mod_var.get(),
"radio_keys": [self.radio1_var.get(), self.radio2_var.get(),
self.radio3_var.get()],
"radio_mods": [self.radio1_mod_var.get(), self.radio2_mod_var.get(),
self.radio3_mod_var.get()],
"hotkey": self.hotkey_var.get(),
"squad_process": self.squad_process_var.get(),
"squad_only": bool(self.squad_only_var.get()),
"pause_on_cursor": bool(self.pause_on_cursor_var.get()),
"beep": bool(self.beep_var.get()),
"modul": self.haupt_nb.index("current"),
}
def suche_update(self):
"""Fragt im Hintergrund nach einer neueren Fassung."""
def arbeit():
angaben = pruefe_update()
if angaben:
self.root.after(0, lambda: self.update_anbieten(angaben))
threading.Thread(target=arbeit, daemon=True).start()
def update_anbieten(self, angaben):
self.update_angaben = angaben
text = f"Version {angaben['version']} ist verfügbar."
if angaben.get("hinweis"):
text += f" {angaben['hinweis']}"
self.update_text_var.set(text)
self.update_banner.pack(side="bottom", fill="x", padx=0, pady=0,
before=self.status_trenner)
def update_verbergen(self):
self.update_banner.pack_forget()
def update_starten(self):
if not getattr(self, "update_angaben", None):
return
ordner = Path(__file__).resolve().parent
# Liegt das Programm unter C:\Program Files, darf es dort ohne
# Adminrechte nichts ersetzen. Bis 3.4 scheiterte das Update dann
# still und startete die alte Fassung neu.
if not update_helfer.beschreibbar(ordner) and not messagebox.askokcancel(
APP_NAME,
"Squad Manager liegt in einem geschuetzten Ordner:\n"
f"{ordner}\n\n"
"Zum Einspielen fragt Windows gleich nach Administratorrechten. "
"Das Programm selbst laeuft danach wieder mit normalen Rechten.\n\n"
"Dauerhaft beheben laesst sich das mit dem aktuellen Installer: "
"Er installiert in deinen Benutzerordner.",
icon="warning"):
return
self.update_btn.config(state="disabled", text="Lädt ...")
def arbeit():
import tempfile
try:
ziel = Path(tempfile.gettempdir()) / "SquadManager_Update.zip"
def melden(geladen, gesamt):
anteil = int(geladen * 100 / gesamt)
self.root.after(0, lambda: self.update_btn.config(
text=f"Lädt ... {anteil} %"))
lade_update(self.update_angaben, ziel, melden)
self.root.after(0, lambda: self.update_abschliessen(ziel, ordner))
except Exception as fehler:
log_exception(type(fehler), fehler, fehler.__traceback__)
self.root.after(0, lambda f=fehler: self.update_fehler(f))
threading.Thread(target=arbeit, daemon=True).start()
def update_fehler(self, fehler):
self.update_btn.config(state="normal", text="Jetzt aktualisieren")
messagebox.showerror(
APP_NAME,
f"Das Update konnte nicht geladen werden:\n\n{fehler}\n\n"
"Das Programm läuft unverändert weiter.")
def update_abschliessen(self, zip_pfad, ordner):
self.update_btn.config(text="Wird eingespielt ...")
try:
spiele_update_ein(zip_pfad, ordner,
self.update_angaben.get("installer", ""))
except Exception as fehler:
log_exception(type(fehler), fehler, fehler.__traceback__)
self.update_fehler(fehler)
return
try:
self.akte.speichern_sofort()
except Exception as e:
log_exception(type(e), e, e.__traceback__)
self.stop()
self.root.after(400, self.root.destroy)
def arm_autosave(self):
"""
Jede Aenderung wird gespeichert, nicht erst beim Schliessen.
Wird das Programm abgeschossen oder faellt der Rechner aus, waeren
sonst alle Einstellungen der Sitzung verloren. Geschrieben wird
verzoegert, damit das Ziehen am Schieberegler nicht hunderte
Schreibvorgaenge ausloest.
"""
for var in (self.device_var, self.threshold_var, self.release_ms_var,
self.ptt_key_var, self.ptt_mod_var,
self.radio1_var, self.radio1_mod_var,
self.radio2_var, self.radio2_mod_var,
self.radio3_var, self.radio3_mod_var,
self.hotkey_var, self.squad_process_var,
self.squad_only_var, self.pause_on_cursor_var,
self.beep_var):
var.trace_add("write", self._on_setting_changed)
self._autosave_job = None
self.haupt_nb.bind("<<NotebookTabChanged>>", self._on_setting_changed,
add="+")
def _on_setting_changed(self, *_):
if getattr(self, "_autosave_job", None) is not None:
try:
self.root.after_cancel(self._autosave_job)
except Exception:
pass
self._autosave_job = self.root.after(600, self._autosave_now)
def _autosave_now(self):
self._autosave_job = None
self.save_config(quiet=True)
def save_config(self, quiet=False):
try:
CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
CONFIG_PATH.write_text(json.dumps(self.config_dict(), indent=2),
encoding="utf-8")
self.save_hint.config(
text=f"Automatisch gespeichert {time.strftime('%H:%M:%S')}")
except Exception as e:
log_exception(type(e), e, e.__traceback__)
if not quiet:
messagebox.showerror(
APP_NAME, f"Einstellungen konnten nicht gespeichert werden:\n{e}")
else:
self.save_hint.config(text="Speichern fehlgeschlagen - siehe error.log")
def load_config(self):
alte_einstellungen_uebernehmen()
if not CONFIG_PATH.exists():
return
try:
cfg = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
except Exception:
return
# Toleranter Vergleich: Geraetenamen enthalten oft ueberzaehlige
# Leerzeichen, und die Namensbereinigung kann sie veraendert haben.
saved = " ".join((cfg.get("device") or "").split())
if saved:
match = next((label for label in self.device_combo["values"]
if " ".join(label.split()) == saved), None)
if match:
self.device_var.set(match)
try:
self.threshold_var.set(float(cfg.get("threshold", 0.025)))
self.release_ms_var.set(int(cfg.get("release_ms", 450)))
except Exception:
pass
self.squad_only_var.set(bool(cfg.get("squad_only", True)))
self.pause_on_cursor_var.set(bool(cfg.get("pause_on_cursor", False)))
self.beep_var.set(bool(cfg.get("beep", True)))
if cfg.get("ptt_key") in KEYS:
self.ptt_key_var.set(cfg["ptt_key"])
if cfg.get("ptt_mod") in MODIFIERS:
self.ptt_mod_var.set(cfg["ptt_mod"])
if cfg.get("hotkey") in KEYS or cfg.get("hotkey") == NONE_LABEL:
self.hotkey_var.set(cfg["hotkey"])
if cfg.get("squad_process"):
self.squad_process_var.set(cfg["squad_process"])
for var, value in zip((self.radio1_var, self.radio2_var, self.radio3_var),
cfg.get("radio_keys") or []):
if value in KEYS or value == NONE_LABEL:
var.set(value)
for var, value in zip((self.radio1_mod_var, self.radio2_mod_var,
self.radio3_mod_var), cfg.get("radio_mods") or []):
if value in MODIFIERS:
var.set(value)
modul = cfg.get("modul")
if isinstance(modul, int) and 0 <= modul < len(self.haupt_nb.tabs()):
self.haupt_nb.select(modul)
self.save_hint.config(text="Einstellungen geladen.")
# -- Audio --------------------------------------------------------------
def refresh_devices(self, rescan=False):
try:
self.inputs = enumerate_inputs(rescan=rescan,
alle=bool(self.alle_geraete_var.get()))
except Exception as e:
messagebox.showerror(APP_NAME, f"Mikrofone konnten nicht gelesen werden:\n{e}")
return
labels = [d["label"] for d in self.inputs]
self.device_combo["values"] = labels
if self.device_var.get() not in labels:
# WASAPI zuerst - moderner und stabiler als MME/DirectSound
preferred = next((d["label"] for d in self.inputs if d["api"] == "WASAPI"),
labels[0] if labels else "")
self.device_var.set(preferred)
def selected_device(self):
"""Loest das gewaehlte Label frisch auf, weil Indizes wandern koennen."""
label = self.device_var.get()
if not label:
return None
for device in enumerate_inputs():
if device["label"] == label:
return device
return None
def audio_callback(self, indata, frames, time_info, status):
rms = float(np.sqrt(np.mean(np.square(indata.astype(np.float32)))))
self.current_level = rms
try:
self.audio_queue.put_nowait(rms)
except queue.Full:
try:
self.audio_queue.get_nowait()
self.audio_queue.put_nowait(rms)
except Exception:
pass
# -- PTT ----------------------------------------------------------------
def test_ptt(self):
if self.ptt_down:
return
key = self.ptt_key_var.get()
mod = self.ptt_mod_var.get()
if key not in KEYS:
messagebox.showwarning(APP_NAME, "Bitte eine gueltige Taste waehlen.")
return
label = key if MODIFIERS.get(mod) is None else f"{mod}+{key}"
self.test_result.config(text=f"Teste {label} ...")
def do_test():
try:
send_binding(mod, key, True)
time.sleep(1.0)
send_binding(mod, key, False)
self.root.after(0, lambda: self.test_result.config(
text=f"{label} wurde erfolgreich gesendet."))
except Exception as e:
self.root.after(0, lambda: messagebox.showerror(
APP_NAME, f"Test fehlgeschlagen:\n{e}"))
self.root.after(0, lambda: self.test_result.config(
text="Test fehlgeschlagen."))
threading.Thread(target=do_test, daemon=True).start()
def press_ptt(self):
if self.ptt_down:
return
key = self.ptt_key_var.get()
if key not in KEYS:
return
# Kombination merken, damit ein spaeteres Umstellen im UI die
# gehaltene Taste nicht haengen laesst.
self.active_binding = (self.ptt_mod_var.get(), key)
send_binding(*self.active_binding, True)
self.ptt_down = True
def release_ptt(self):
if not self.ptt_down:
return
try:
if self.active_binding:
send_binding(*self.active_binding, False)
finally:
self.active_binding = None
self.ptt_down = False
# -- Sperrgruende -------------------------------------------------------
def radio_bindings(self):
pairs = ((self.radio1_mod_var, self.radio1_var),
(self.radio2_mod_var, self.radio2_var),
(self.radio3_mod_var, self.radio3_var))
return [(m.get(), k.get()) for m, k in pairs if k.get() in KEYS]
def squad_focused(self):
"""Ist das Spiel gerade das aktive Fenster?"""
if not self.squad_only_var.get():
return True
wanted = self.squad_process_var.get().strip().lower()
if not wanted:
return True
return get_foreground_process_name().lower().startswith(wanted)
def blocking_reason(self):
"""Grund, warum gerade nicht gesendet werden darf. Leerer String = frei."""
if not self.squad_focused():
return "Squad nicht im Vordergrund"
if not self.enabled_var.get():
return "Pausiert (Hotkey)"
for mod, key in self.radio_bindings():
if is_binding_down(mod, key):
label = key if MODIFIERS.get(mod) is None else f"{mod}+{key}"
return f"Funk aktiv ({label})"
# Haelt der Spieler die Local-Taste selbst, mischen wir uns nicht ein.
if not self.ptt_down and is_binding_down(self.ptt_mod_var.get(),
self.ptt_key_var.get()):
return "Manuell gedrueckt"
if self.pause_on_cursor_var.get() and cursor_is_visible():
return "Menue / Deploy-Screen"
return ""
def poll_hotkey(self):
"""
Flankenerkennung fuer den Stummschalt-Hotkey.
Wird nur ausgewertet, solange das Spiel im Vordergrund ist. Sonst
wuerde dieselbe Taste auch beim Schreiben im Browser oder in Discord
die Automatik umschalten.
"""
key = self.hotkey_var.get()
if key not in KEYS or not self.squad_focused():
self.hotkey_was_down = False
return
down = is_physically_down(key)
if down and not self.hotkey_was_down:
now_enabled = not self.enabled_var.get()
self.enabled_var.set(now_enabled)
if not now_enabled:
self.release_ptt()
if self.beep_var.get():
beep(now_enabled)
self.hotkey_was_down = down
# -- Steuerung ----------------------------------------------------------
def start(self):
if self.running:
return
if not audio_service_running():
messagebox.showerror(
APP_NAME,
"Der Windows-Audiodienst laeuft nicht.\n\n"
"Ohne ihn kann kein Programm aufnehmen. In einer\n"
"Eingabeaufforderung als Administrator starten:\n\n"
" net start Audiosrv")
return
device = self.selected_device()
if device is None:
messagebox.showwarning(
APP_NAME,
"Das gewaehlte Mikrofon ist nicht mehr vorhanden.\n"
"Bitte auf 'Neu laden' klicken und erneut waehlen.")
return
rate = pick_samplerate(device["index"], device["samplerate"])
if rate is None:
messagebox.showerror(
APP_NAME,
f"{device['name']} akzeptiert keine der ueblichen Abtastraten.\n"
"Bitte ein anderes Geraet waehlen - moeglichst eines mit [WASAPI].")
return
try:
self.audio_queue = queue.Queue(maxsize=10)
self.running = True
self.enabled_var.set(True)
self.last_voice_time = 0.0
self.stream = sd.InputStream(
device=device["index"], channels=1, samplerate=rate,
blocksize=max(64, rate // 50), # rund 20 ms
dtype="float32", callback=self.audio_callback,
)
self.stream.start()
self.worker = threading.Thread(target=self.worker_loop, daemon=True)
self.worker.start()
self.start_btn.config(state="disabled")
self.stop_btn.config(state="normal")
self.device_combo.config(state="disabled")
self.device_info_var.set(f"{device['api']} @ {rate} Hz")
except Exception as e:
self.running = False
self.stream = None
log_exception(type(e), e, e.__traceback__)
messagebox.showerror(
APP_NAME,
f"Mikrofon konnte nicht geoeffnet werden:\n\n{e}\n\n"
"Haeufige Ursachen:\n"
"- Windows-Audiodienst abgestuerzt (net start Audiosrv)\n"
"- Geraet von einem anderen Programm exklusiv belegt\n"
"- Virtueller Treiber (z. B. SteelSeries Sonar) haengt\n\n"
"Ein Geraet mit [WASAPI] ist meist am stabilsten.")
def stop(self):
self.running = False
# Erst den Worker auslaufen lassen, sonst greift er noch auf den
# Stream zu, waehrend dieser geschlossen wird - das kann PortAudio
# hart abstuerzen lassen.
worker, self.worker = self.worker, None
if worker is not None and worker.is_alive():
worker.join(timeout=1.0)
try:
self.release_ptt()
except Exception as e:
log_exception(type(e), e, e.__traceback__)
self.ptt_down = False
self.active_binding = None
stream, self.stream = self.stream, None
if stream is not None:
try:
stream.abort(ignore_errors=True)
except Exception:
pass
try:
stream.close(ignore_errors=True)
except Exception as e:
log_exception(type(e), e, e.__traceback__)
self.current_level = 0.0
self.hold_reason = ""
self.start_btn.config(state="normal")
self.stop_btn.config(state="disabled")
self.device_combo.config(state="readonly")
def worker_loop(self):
while self.running:
try:
rms = self.audio_queue.get(timeout=self.POLL_SECONDS)
except queue.Empty:
rms = 0.0
now = time.monotonic()
try:
threshold = float(self.threshold_var.get())
release_delay = max(0.05, int(self.release_ms_var.get()) / 1000.0)
except Exception:
threshold, release_delay = 0.025, 0.45
try:
self.poll_hotkey()
reason = self.blocking_reason()
self.hold_reason = reason
if reason:
self.release_ptt()
elif rms >= threshold:
self.last_voice_time = now
self.press_ptt()
elif self.ptt_down and now - self.last_voice_time >= release_delay:
self.release_ptt()
except Exception as e:
self.running = False
self.root.after(0, lambda err=e: messagebox.showerror(
APP_NAME,
f"Tastatureingabe fehlgeschlagen:\n{err}\n\n"
"Zuerst den PTT-Test ausserhalb von Squad probieren.\n"
"Laeuft Squad als Administrator, muss auch dieses "
"Programm als Administrator laufen."))
break
try:
self.release_ptt()
except Exception:
pass
# -- Anzeige ------------------------------------------------------------
def ui_tick(self):
try:
val = float(self.current_level)
self.level_bar.update_values(val, float(self.threshold_var.get()),
self.ptt_down)
self.level_label.config(text=f"{val:.3f}")
self.threshold_label.config(text=f"{self.threshold_var.get():.3f}")
self.cursor_hint.config(
text="Mauszeiger gerade sichtbar" if cursor_is_visible()
else "Mauszeiger gerade ausgeblendet")
self.proc_hint.config(
text=f"gerade im Vordergrund: {get_foreground_process_name() or '?'}")
threshold = float(self.threshold_var.get())
if not self.running:
self.status_var.set("● BEREITSCHAFT")
self.status_label.config(foreground=FG_DIM)
self.detail_var.set("")
self.diag_var.set("Nicht gestartet - unten auf STARTEN klicken.")
else:
laut = "ueber Schwelle" if val >= threshold else "ZU LEISE"
zeilen = [f"Pegel {val:.4f} / Schwelle {threshold:.4f} -> {laut}"]
if self.ptt_down:
self.status_var.set("● SENDET")
self.status_label.config(foreground=GREEN_TX)
self.detail_var.set("")
zeilen.append("Taste wird gehalten.")
elif self.hold_reason:
self.status_var.set("● GESPERRT")
self.status_label.config(foreground=RED)
self.detail_var.set(self.hold_reason)
zeilen.append(f"Blockiert: {self.hold_reason}")
if self.hold_reason == "Squad nicht im Vordergrund":
zeilen.append(" -> Squad anklicken, oder den Haken im")
zeilen.append(" Reiter 'Tasten und Verhalten' entfernen.")
else:
self.status_var.set("● HORCHT")
self.status_label.config(foreground=AMBER)
self.detail_var.set("")
zeilen.append("Nichts blockiert - es fehlt nur lautes Sprechen.")
self.diag_var.set("\n".join(zeilen))
except Exception:
pass
self.root.after(80, self.ui_tick)
def on_close(self):
try:
self.akte.speichern_sofort()
except Exception as e:
log_exception(type(e), e, e.__traceback__)
try:
self.save_config()
except Exception:
pass
self.stop()
self.root.destroy()
def main():
root = tk.Tk()
try:
apply_tactical_theme(root)
except Exception as e:
log_exception(type(e), e, e.__traceback__)
VoiceActivationApp(root)
root.mainloop()
if __name__ == "__main__":
main()