""" 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 APP_NAME = "Squad Manager" VERSION = "3.3" 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 ziel = str(angaben.get("version", "")).strip() datei = str(angaben.get("datei", "")).strip() if not ziel or not datei.lower().startswith("https://"): return None if version_tupel(ziel) <= version_tupel(VERSION): return None return { "version": ziel, "datei": datei, "sha256": str(angaben.get("sha256", "")).strip().lower(), "hinweis": str(angaben.get("hinweis", "")).strip()[:200], } 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): """ Entpackt das Paket und startet einen Helfer, der die Dateien ersetzt. Das laufende Programm kann seine eigenen Dateien nicht ueberschreiben. Deshalb uebernimmt ein kleines Skript das Kopieren, nachdem sich das Programm beendet hat, und startet es anschliessend neu. """ import subprocess import tempfile import zipfile arbeit = Path(tempfile.mkdtemp(prefix="sva_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 helfer = arbeit / "einspielen.bat" helfer.write_text( "@echo off\r\n" "ping -n 4 127.0.0.1 >nul\r\n" f'xcopy /e /y /i /q "{quelle}\\*" "{programm_ordner}\\" >nul\r\n' f'start "" "{sys.executable}" "{programm_ordner}\\start.pyw"\r\n' "ping -n 2 127.0.0.1 >nul\r\n" f'rmdir /s /q "{arbeit}"\r\n', encoding="ascii") subprocess.Popen(["cmd", "/c", str(helfer)], 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) # --------------------------------------------------------------------------- # Erscheinungsbild - gedeckte Militaerfarben, dunkler Untergrund # --------------------------------------------------------------------------- BG = "#151814" # Fensterhintergrund, fast schwarz mit Gruenstich PANEL = "#1e231b" # Flaechen, Eingabefelder PANEL_HI = "#2a3125" # Hover, ausgewaehlter Reiter LINE = "#3d4634" # Rahmen und Trennlinien FG = "#c9cec0" # Standardtext, helles Khaki FG_DIM = "#7f8874" # Nebentext OLIVE = "#6e8b3d" # Akzent, Fortschritt OLIVE_HI = "#8cb04d" # heller Akzent AMBER = "#d9a441" # Hinweise, Schwellenmarke AMBER_HELL = "#e8bb63" # Mauskontakt auf der Hinweisleiste AMBER_DUNKEL = "#2b2416" # Untergrund der Hinweisleiste RED = "#b4472f" # Sperre, Fehler GREEN_TX = "#9ed23f" # Sendebereit FONT_UI = ("Segoe UI", 9) FONT_BOLD = ("Segoe UI Semibold", 9) FONT_TITLE = ("Segoe UI", 17, "bold") FONT_MONO = ("Consolas", 9) FONT_STATUS = ("Consolas", 13, "bold") def apply_tactical_theme(root): """Dunkles, gedecktes Farbschema im Stil der Spieloberflaeche.""" root.configure(bg=BG) style = ttk.Style(root) # "clam" ist das einzige mitgelieferte Thema, das sich durchgaengig # umfaerben laesst - "vista" ignoriert die meisten Farbangaben. style.theme_use("clam") style.configure(".", background=BG, foreground=FG, font=FONT_UI, bordercolor=LINE, darkcolor=PANEL, lightcolor=PANEL, troughcolor=PANEL, focuscolor=OLIVE) style.configure("TFrame", background=BG) style.configure("TLabel", background=BG, foreground=FG) style.configure("Dim.TLabel", foreground=FG_DIM) style.configure("Mono.TLabel", font=FONT_MONO, foreground=FG) style.configure("Title.TLabel", font=FONT_TITLE, foreground=FG) style.configure("Sub.TLabel", foreground=FG_DIM) style.configure("TLabelframe", background=BG, bordercolor=LINE, relief="solid", borderwidth=1) style.configure("TLabelframe.Label", background=BG, foreground=OLIVE_HI, font=FONT_BOLD) style.configure("TButton", background=PANEL, foreground=FG, bordercolor=LINE, relief="solid", borderwidth=1, padding=(12, 6), font=FONT_UI) style.map("TButton", background=[("pressed", OLIVE), ("active", PANEL_HI), ("disabled", PANEL)], foreground=[("disabled", FG_DIM)], bordercolor=[("active", OLIVE)]) style.configure("Accent.TButton", background=OLIVE, foreground="#12150f", font=FONT_BOLD, bordercolor=OLIVE_HI) style.map("Accent.TButton", background=[("pressed", OLIVE), ("active", OLIVE_HI), ("disabled", PANEL)], foreground=[("disabled", FG_DIM)]) for widget in ("TCombobox", "TSpinbox", "TEntry"): style.configure(widget, fieldbackground=PANEL, background=PANEL, foreground=FG, bordercolor=LINE, arrowcolor=OLIVE_HI, insertcolor=FG, selectbackground=OLIVE, selectforeground="#12150f", padding=4) style.map(widget, fieldbackground=[("readonly", PANEL), ("disabled", BG)], foreground=[("disabled", FG_DIM)], bordercolor=[("focus", OLIVE)]) # Die aufklappende Liste einer Combobox ist ein klassisches Tk-Widget # und muss ueber die Optionsdatenbank eingefaerbt werden. root.option_add("*TCombobox*Listbox.background", PANEL) root.option_add("*TCombobox*Listbox.foreground", FG) root.option_add("*TCombobox*Listbox.selectBackground", OLIVE) root.option_add("*TCombobox*Listbox.selectForeground", "#12150f") root.option_add("*TCombobox*Listbox.font", FONT_UI) style.configure("TCheckbutton", background=BG, foreground=FG, indicatorcolor=PANEL, indicatorrelief="solid") style.map("TCheckbutton", background=[("active", BG)], indicatorcolor=[("selected", OLIVE_HI), ("active", PANEL_HI)], foreground=[("disabled", FG_DIM)]) style.configure("TNotebook", background=BG, bordercolor=LINE, tabmargins=(2, 4, 2, 0)) style.configure("TNotebook.Tab", background="#10120f", foreground=FG_DIM, bordercolor=LINE, lightcolor="#10120f", darkcolor="#10120f", padding=(20, 9), font=FONT_BOLD) style.map("TNotebook.Tab", background=[("selected", PANEL_HI), ("active", PANEL)], lightcolor=[("selected", PANEL_HI)], darkcolor=[("selected", PANEL_HI)], foreground=[("selected", OLIVE_HI), ("active", FG)], expand=[("selected", (0, 0, 0, 0))]) # Der Schieberegler von clam ist standardmaessig hell und wuerde aus # dem Schema fallen. style.configure("Horizontal.TScale", background=BG, troughcolor="#10120f", bordercolor=LINE, lightcolor=OLIVE, darkcolor=OLIVE) style.map("Horizontal.TScale", background=[("active", BG)], lightcolor=[("active", OLIVE_HI)], darkcolor=[("active", OLIVE_HI)]) style.configure("TSeparator", background=LINE) return style class LevelMeter(tk.Canvas): """ Segmentierte Pegelanzeige mit Schwellenmarke. Zeigt anders als eine gewoehnliche Fortschrittsleiste, wo die Ausloeseschwelle relativ zum Pegel liegt - genau die Information, die man zum Einstellen braucht. """ SEGMENTS = 40 MAXIMUM = 0.10 def __init__(self, master, width=320, height=26): super().__init__(master, width=width, height=height, bg=PANEL, highlightthickness=1, highlightbackground=LINE, bd=0) self._level = 0.0 self._threshold = 0.025 self._active = False self.bind("", lambda e: self._redraw()) def update_values(self, level, threshold, active): self._level, self._threshold, self._active = level, threshold, active self._redraw() def _redraw(self): self.delete("all") w = self.winfo_width() or int(self["width"]) h = self.winfo_height() or int(self["height"]) pad = 3 seg_w = (w - 2 * pad) / self.SEGMENTS filled = int(min(1.0, self._level / self.MAXIMUM) * self.SEGMENTS) thr_seg = int(min(1.0, self._threshold / self.MAXIMUM) * self.SEGMENTS) for i in range(self.SEGMENTS): x0 = pad + i * seg_w x1 = x0 + seg_w - 1.5 if i < filled: colour = OLIVE_HI if self._active else OLIVE if i >= thr_seg and not self._active: colour = OLIVE_HI else: colour = "#252b1f" self.create_rectangle(x0, pad, x1, h - pad, fill=colour, width=0) # Schwellenmarke x = pad + thr_seg * seg_w self.create_line(x, 0, x, h, fill=AMBER, width=2) 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("700x780") self.root.minsize(660, 480) 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="Haelt die Sprechtaste, solange du redest.").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() nb = ttk.Notebook(self.root) self.nb = nb nb.pack(fill="both", expand=True, padx=16, pady=8) 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) 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()), } 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 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) ordner = Path(__file__).resolve().parent 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) except Exception as fehler: log_exception(type(fehler), fehler, fehler.__traceback__) self.update_fehler(fehler) return 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 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) 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.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()