commit f986c3ad111b57798908893d3a387dd85b1d6a30 Author: danny Date: Thu Sep 10 17:22:54 2026 +0200 Squad Voice Activation 3.2 - Ausgangsstand Windows-Werkzeug, das die Sprechtaste in Squad haelt, solange man redet. - Hauptprogramm mit tkinter-Oberflaeche, Pegelanzeige und Diagnose - Auto-Updater gegen https://sva.tyrveil.com/version.json mit SHA-256-Pruefung - Inno-Setup-Installer und Build-Skript werkzeuge/baue_release.py - Projektuebergabe mit den bekannten Fallstricken Co-Authored-By: Claude Opus 5 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..27c7e11 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,13 @@ +# Windows-Skripte brauchen CRLF - mit LF brechen Sprungmarken und Bloecke +*.bat text eol=crlf +*.vbs text eol=crlf +*.iss text eol=crlf +*.txt text eol=crlf + +# Python einheitlich mit LF +*.py text eol=lf +*.pyw text eol=lf +*.md text eol=lf + +*.png binary +*.ico binary diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b90922b --- /dev/null +++ b/.gitignore @@ -0,0 +1,11 @@ +# Laufzeitumgebung - enthaelt feste Pfade und wird bei jeder Installation neu angelegt +.venv/ + +# Erzeugte Dateien - entstehen durch werkzeuge/baue_release.py +dist/ +__pycache__/ +*.pyc + +# Editor +.idea/ +.vscode/ diff --git a/Design-Briefing.md b/Design-Briefing.md new file mode 100644 index 0000000..921d464 --- /dev/null +++ b/Design-Briefing.md @@ -0,0 +1,255 @@ +# Design-Briefing: Squad Voice Activation 3.0 + +Zwei Aufgaben, in dieser Reihenfolge: + +- **Teil A** — ein Design System (Farben, Schrift, Abstände, Bausteine) +- **Teil B** — die beiden Bildschirme des Programms, gebaut aus Teil A + +--- + +## Ausgangslage + +Ein Windows-Desktop-Werkzeug für den Taktik-Shooter **Squad**. Es misst +laufend den Mikrofonpegel und hält die Sprechtaste des Spiels automatisch +gedrückt, solange der Spieler redet — Voice Activation für ein Spiel, das +nur Push-to-Talk kennt. + +Kein Overlay, kein Spielinhalt: ein eigenständiges Fenster neben dem Spiel. +Es wird zum Einrichten geöffnet und im Betrieb nur kurz angeschaut, um +einen Zustand abzulesen. + +**Nutzer:** Squad-Spieler, überwiegend erwachsen, Mil-Sim-affin, technisch +interessiert. Vertraut mit Begriffen wie Local, Squad Radio, Command Radio, +WASAPI. Sie mögen nüchterne Werkzeuge und misstrauen verspielten +Oberflächen. + +**Anmutung:** Militärisch-funktional, nüchtern, dunkel. Nähe zur +Bildsprache des Spiels — gedecktes Olivgrün, Sandtöne, dunkles Metall, +Beschriftungen wie auf Gerätefronten. Kein Neon, keine Verläufe, keine +Spielereien. Eher Feldfunkgerät als Consumer-App. + +**Oberstes Ziel:** Ablesbarkeit. Der Nutzer kommt aus einem Vollbild-Spiel +und muss den Zustand in einer halben Sekunde erfassen. + +--- + +# TEIL A — Design System + +Gesucht ist ein kleines, konsequentes System für genau diese Art von +Werkzeug. Bitte als benannte Gestaltungsmerkmale anlegen, damit sie in +Teil B wiederverwendet werden können. + +## A1 Farben + +Als Rollen definieren, nicht nur als Werte. Benötigt werden mindestens: + +- Fensterhintergrund (dunkelste Ebene) +- Flächenfarbe für Eingabefelder und Kästen +- gehobene Fläche für aktiven Reiter und Mauskontakt +- Rahmen- und Trennlinienfarbe +- Textfarbe, Nebentextfarbe +- Akzentfarbe (Olivgrün) in normal und hell +- Signalfarben: Bernstein (Hinweis, Schwelle), Grün (aktiv/sendet), + Rot (gesperrt), Grau (untätig) + +Bisher verwendete Werte als Ausgangspunkt, gern verbessern: + +| Rolle | Wert | +|---|---| +| Fensterhintergrund | `#151814` | +| Fläche | `#1e231b` | +| Fläche gehoben | `#2a3125` | +| Linie | `#3d4634` | +| Text | `#c9cec0` | +| Nebentext | `#7f8874` | +| Akzent | `#6e8b3d` | +| Akzent hell | `#8cb04d` | +| Bernstein | `#d9a441` | +| Rot | `#b4472f` | +| Grün aktiv | `#9ed23f` | + +## A2 Schrift + +Zwei Familien, klar getrennt in der Aufgabe: + +- **Beschriftungen und Fließtext** — serifenlos, gut lesbar (bisher Segoe UI) +- **Messwerte, Diagnose, Zustandsanzeige** — dicktengleich (bisher Consolas) + +Gesucht ist eine Skala mit etwa fünf Stufen: Fenstertitel, Kastenüberschrift, +Beschriftung, Nebentext, Zustandsanzeige. Versalien sparsam einsetzen — +bisher nur für Fenstertitel und die Knöpfe der Statusleiste. + +## A3 Raster und Abstände + +Formularzeilen: links Beschriftung, rechts Bedienelement, konsistent +ausgerichtet. Bitte eine Abstandsskala festlegen (Innenabstand von Kästen, +Zeilenabstand, Abstand zwischen Gruppen) und durchhalten. + +## A4 Bausteine + +Für jeden Baustein die Zustände *normal*, *Mauskontakt*, *Fokus* und +*deaktiviert* mitdenken: + +1. **Knopf, primär** — nur einmal pro Fenster (STARTEN) +2. **Knopf, sekundär** — normale Aktionen, deaktivierbar +3. **Auswahlliste** — auch mit sehr langen Einträgen wie + `[WASAPI] Analogue 1 + 2 (Focusrite USB Audio)`; zusätzlich eine + schmale Variante für Tastenauswahl +4. **Textfeld** — einzeilig +5. **Zahlenfeld** mit Schrittpfeilen +6. **Schieberegler** mit Zahlenanzeige daneben +7. **Kontrollkästchen** mit ein- und zweizeiliger Beschriftung +8. **Reiter** — genau zwei, aktiver deutlich abgesetzt +9. **Gerahmter Kasten** mit Überschrift in der Rahmenlinie +10. **Diagnosefeld** — mehrzeilig, dicktengleich, gerahmt +11. **Pegelanzeige** — siehe A5 +12. **Zustandsanzeige** — siehe A6 +13. **Statuszeile** — dezente, mitlaufende Textzeile unter einem Element +14. **Hinweistext** — mehrzeilig, gedämpft + +## A5 Pegelanzeige — Kernstück + +Kein gewöhnlicher Fortschrittsbalken. Etwa 40 schmale senkrechte Segmente +in einem Rahmen. Gefüllte Segmente zeigen den aktuellen Pegel, leere +bleiben dunkel. Eine **senkrechte bernsteinfarbene Marke** steht an der +Position der Auslöseschwelle. + +Der Nutzen: Man sieht sofort, ob die eigene Stimme über die Schwelle kommt. +Bleiben die gefüllten Segmente links der Marke, löst nichts aus. Genau +daran scheitern Nutzer beim Einrichten — deshalb ist das der wichtigste +Blickfang des Fensters. + +Bitte auch entwerfen, wie die Anzeige im aktiven Zustand (es wird gerade +gesendet) anders aussieht als im horchenden. + +## A6 Zustandsanzeige + +Vier sich ausschließende Zustände, jeweils Punkt plus Text: + +| Zustand | Text | Farbe | Bedeutung | +|---|---|---|---| +| gestoppt | ● BEREITSCHAFT | grau | läuft nicht | +| bereit | ● HORCHT | bernstein | läuft, wartet auf Stimme | +| aktiv | ● SENDET | grün | Taste wird gerade gehalten | +| blockiert | ● GESPERRT | rot | pausiert, Grund steht daneben | + +Muss aus zwei Metern Abstand erkennbar sein. Farbe allein darf nicht das +einzige Unterscheidungsmerkmal sein. + +--- + +# TEIL B — Die Bildschirme + +Ein Fenster, Standardgröße **700 × 780 px**, verkleinerbar bis etwa +660 × 480. Aufbau von oben nach unten: Kopfbereich, zwei Reiter, +Statusleiste am unteren Rand (immer sichtbar, auch bei kleinem Fenster). + +## Kopfbereich + +- Titel **SQUAD VOICE ACTIVATION** +- Untertitel „Hält die Sprechtaste, solange du redest." +- Trennlinie darunter + +## Bildschirm 1 — Reiter „Mikrofon" + +Formularzeilen: + +| Beschriftung | Bedienelement | Anmerkung | +|---|---|---| +| Mikrofon | Auswahlliste + Knopf „Neu laden" | lange Einträge, Präfix `[WASAPI]` / `[MME]` | +| Schwelle | Schieberegler + Zahlenwert | 0.002 bis 0.100, dreistellig angezeigt | +| Pegel | **Pegelanzeige** + Zahlenwert | das Kernstück aus A5 | +| Nachlaufzeit | Zahlenfeld + „ms nach dem letzten Wort" | 100 bis 2000 | + +Darunter zwei gerahmte Kästen: + +**„Warum sendet es (nicht)?"** — Diagnosefeld, zwei bis vier Zeilen. +Beispielinhalt: + +``` +Pegel 0.0413 / Schwelle 0.0250 -> über Schwelle +Blockiert: Squad nicht im Vordergrund + -> Squad anklicken, oder den Haken im + Reiter 'Tasten und Verhalten' entfernen. +``` + +**„Eingabetest"** — Knopf „PTT-Taste testen (1 Sekunde halten)" plus +Ergebnistext daneben. + +Abschließend ein vierzeiliger Hinweistext in gedämpfter Farbe. + +## Bildschirm 2 — Reiter „Tasten und Verhalten" + +- Zeile **Sprechtaste**: schmale Auswahlliste (Zusatztaste), ein „+", + schmale Auswahlliste (Taste), dahinter grauer Hinweis +- Gerahmter Kasten **„Andere Sprechtasten — Automatik pausiert, solange + eine gehalten wird"** mit drei gleich aufgebauten Zeilen: + + | Beschriftung | Zusatztaste | | Taste | Hinweis | + |---|---|---|---|---| + | Squad Radio | (kein) | + | B | meist B | + | Command Radio | (kein) | + | G | meist G | + | Weitere Taste | (kein) | + | (keine) | optional | + +- Dreizeiliger Erklärtext +- Gerahmter Kasten **„Verhalten"**: + - Kontrollkästchen „Alles nur aktiv, solange dieses Programm im + Vordergrund ist:" — darunter eingerückt ein Textfeld mit dem + Prozessnamen und eine mitlaufende Statuszeile + („gerade im Vordergrund: SquadGame-Win64-Shipping.exe") + - Kontrollkästchen „Pausieren, solange ein Mauszeiger sichtbar ist + (Deploy-Screen, Menü, Karte)" — darunter mitlaufende Statuszeile + („Mauszeiger gerade ausgeblendet") + - Zeile „Stummschalt-Hotkey (nur im Spiel)" + schmale Auswahlliste + - Kontrollkästchen „Signalton beim Umschalten (hoch = aktiv, tief = stumm)" +- Zum Abschluss eine dezente Zeile „Alle Änderungen werden sofort + gespeichert." mit Zeitstempel der letzten Speicherung + +## Statusleiste + +Über die volle Breite, oben abgetrennt durch eine Linie. + +- Links: **STARTEN** (der einzige primäre Knopf im ganzen Fenster) und + **STOPPEN** (sekundär, im Ruhezustand deaktiviert) +- Rechts: Detailtext (etwa „Funk aktiv (B)" oder „WASAPI @ 48000 Hz") und + daneben die Zustandsanzeige aus A6 + +## Bitte zusätzlich zeigen + +Die Zustandsanzeige und die Pegelanzeige sind die einzigen Elemente, die im +laufenden Betrieb wirklich abgelesen werden. Deshalb wären hilfreich: + +1. Bildschirm 1 im Zustand **SENDET** — Pegel über der Schwelle +2. Bildschirm 1 im Zustand **GESPERRT** — Pegel über der Schwelle, aber + blockiert, mit Grund im Diagnosefeld +3. Die vier Zustände der Zustandsanzeige nebeneinander + +--- + +## Technische Rahmenbedingungen + +Die Oberfläche ist mit **Python und Tkinter/ttk** gebaut. Das begrenzt, was +sich unmittelbar umsetzen lässt: + +**Gut machbar:** freie Farben für Flächen, Text und Rahmen; eigene +Schriftarten und -größen; Rahmen und Trennlinien; beliebige Grafik auf +einer Zeichenfläche (die Pegelanzeige ist bereits so gebaut — dort ist +gestalterisch fast alles möglich); Bilder als Symbole. + +**Nicht oder nur mit erheblichem Aufwand:** abgerundete Ecken an +Standardelementen, Schlagschatten, Verläufe hinter Bedienelementen, +Transparenz, weiche Animationen, Platzhaltertexte in Eingabefeldern. + +Ein Entwurf darf gern darüber hinausgehen. Dann bitte kenntlich machen, +welche Teile über den Standardumfang hinausgehen — sie müssten dann als +selbstgezeichnete Flächen entstehen oder ein anderes Oberflächen-Werkzeug +erfordern. + +## Woran der Entwurf gemessen wird + +1. Der Zustand ist auf einen Blick erfassbar, auch aus zwei Metern. +2. Die Beziehung zwischen Pegel und Schwelle wird sofort verständlich — + das ist die häufigste Hürde beim Einrichten. +3. Der zweite Reiter mit seinen vielen Auswahlfeldern wirkt geordnet, + nicht überladen. +4. Es sieht nach Werkzeug aus, nicht nach Spielerei. diff --git a/PROJEKT-UEBERGABE.md b/PROJEKT-UEBERGABE.md new file mode 100644 index 0000000..7c5d8c0 --- /dev/null +++ b/PROJEKT-UEBERGABE.md @@ -0,0 +1,314 @@ +# Projektübergabe: Squad Voice Activation + +Stand: 10. September 2026 · Version 3.2 · Git-Repository im Quellordner + +Seit 3.2 wird über einen Inno-Setup-Installer und einen eingebauten +Auto-Updater verteilt (Server: https://sva.tyrveil.com), siehe Abschnitt 4. + +Dieses Dokument richtet sich an eine neue Claude-Sitzung ohne Vorwissen. +Es beschreibt, was das Projekt ist, wie es aufgebaut ist und vor allem: +welche Fallstricke bereits teuer gelernt wurden. Die Abschnitte +„Hart erkaufte Erkenntnisse" und „Offene Punkte" sind die wichtigsten. + +--- + +## 1. Was es ist + +Ein Windows-Desktop-Werkzeug in Python für den Taktik-Shooter **Squad**. +Es misst laufend den Mikrofonpegel und hält per simuliertem Tastendruck die +Sprechtaste des Spiels gedrückt, solange der Nutzer redet — also Voice +Activation für ein Spiel, das nur Push-to-Talk kennt. + +Kein Eingriff ins Spiel: kein Hook, keine DLL-Injektion, kein +Speicherzugriff, keine veränderten Spieldateien. Ausschließlich +`SendInput` und `GetAsyncKeyState` über `ctypes`. + +**Nutzer:** Ein einzelner Anwender (deutschsprachig, spielt Squad) und sein +Freundeskreis, an den er das Programm weitergibt. Sprache der Oberfläche +und aller Dokumente ist Deutsch. + +--- + +## 2. Ordner + +Es gibt drei getrennte Orte. Das zu verwechseln war bereits mehrfach die +Fehlerquelle. + +### `C:\Users\danie\Downloads\Squad_Local_Voice_Activation_v2\` — Quelle + +Arbeitsverzeichnis. Hier wird entwickelt. Der Code enthält hier +**Kommentare**, und Texte stehen teils in Ersatzschreibung („Haelt"). + +``` +squad_voice_activation.py Hauptprogramm, rund 1200 Zeilen, eine Datei +start.pyw Startskript ohne Konsolenfenster +make_icon.py erzeugt icon.ico aus icon.png +icon.png / icon.ico Programmsymbol (vom Nutzer geliefert) +requirements.txt numpy, sounddevice +werkzeuge/ Hilfsskripte für den Paketbau, siehe Abschnitt 4 +README.md kurze Orientierung im Ordner +PROJEKT-UEBERGABE.md dieses Dokument +Design-Briefing.md Auftrag für Claude Design, siehe Offene Punkte +``` + +**Aufteilung der Pflege:** Nur die drei Python-Dateien werden hier +gepflegt und für das Paket aufbereitet. Die Skripte `Setup.bat`, +`Update.bat`, `Deinstallieren.bat`, `Fehlersuche.bat` und `Starter.vbs` +durchlaufen keine Aufbereitung und werden **direkt im Paket** gepflegt — +es gibt bewusst keine zweite Kopie in der Quelle. + +### `C:\Users\danie\Downloads\Squad Voice Activation 3.1\` — altes Paket + +**Vorgängerweg, seit 3.2 ersetzt** durch `dist/` und den Installer +(Abschnitt 4). Nur noch relevant, weil die lokale Installation des Nutzers +darüber eingerichtet wurde. Enthält Code ohne Kommentare und mit echten +Umlauten. + +``` +Setup.bat Erstinstallation +Update.bat Aktualisierung einer vorhandenen Installation +ANLEITUNG.txt Endnutzer-Dokumentation +Programm/ + squad_voice_activation.py + start.pyw + make_icon.py + Starter.vbs portabler Start ohne Installation + Fehlersuche.bat Start mit sichtbarer Konsole + Deinstallieren.bat + requirements.txt + icon.png / icon.ico +``` + +Dazu `Downloads\SquadVoiceActivation-3.1.zip` als Versandfassung. + +### `%LOCALAPPDATA%\Programs\SquadVoiceActivation\` — Installation + +Zielverzeichnis. Enthält zusätzlich `.venv\`. Konfiguration und Fehlerlog +liegen getrennt davon in `%APPDATA%\SquadVoiceActivation\`. + +--- + +## 3. Aufbau des Programms + +Eine einzelne Datei, `tkinter`/`ttk`, keine Klassenhierarchie außer der +Hauptklasse `VoiceActivationApp`. + +**Ablauf:** `sounddevice.InputStream` liefert Audioblöcke an einen +Callback, der den RMS-Pegel berechnet und in eine Queue legt. Ein +Arbeitsthread (`worker_loop`) liest daraus, prüft Sperrgründe und drückt +bzw. löst die Taste. Die Oberfläche aktualisiert sich unabhängig alle 80 ms +über `ui_tick`. + +**Zentrale Funktion:** `blocking_reason()` gibt den Grund zurück, warum +gerade nicht gesendet werden darf, oder einen leeren String. Reihenfolge: + +1. Spiel nicht im Vordergrund +2. per Hotkey stummgeschaltet +3. eine Funktaste wird gehalten +4. die Sprechtaste wird manuell gedrückt +5. Mauszeiger sichtbar (optional) + +**Funktionen von Bedeutung:** + +| Funktion | Zweck | +|---|---| +| `enumerate_inputs()` | Geräteliste, siehe Erkenntnis 5 | +| `squad_focused()` | Prozessname des Vordergrundfensters prüfen | +| `send_binding()` | Taste plus Zusatztaste drücken/lösen | +| `apply_tactical_theme()` | dunkles Farbschema | +| `LevelMeter` | segmentierte Pegelanzeige mit Schwellenmarke | +| `set_dark_titlebar()` | Fenstertitelleiste dunkel | +| `arm_autosave()` | speichert Einstellungen 600 ms nach jeder Änderung | + +**Oberfläche:** Zwei Reiter („Mikrofon", „Tasten und Verhalten") plus eine +Statusleiste mit den Knöpfen und der Zustandsanzeige (BEREITSCHAFT / +HORCHT / SENDET / GESPERRT). + +--- + +## 4. Release bauen, Installer und Updater + +Ein Befehl erzeugt alles: + +``` +.venv\Scripts\python.exe werkzeuge\baue_release.py +``` + +Die Version kommt aus `VERSION` in `squad_voice_activation.py`. Ergebnis in +`dist/` (nicht im Repository): aufbereitete Programmdateien, das +Update-Paket `SquadVoiceActivation-.zip`, der Installer +`SquadVoiceActivation-Setup-.exe` und `dist/server/` mit genau den +Dateien zum Hochladen samt `version.json` (Prüfsumme wird eingetragen). + +**Installer:** Inno Setup 6.7.3 unter +`%LOCALAPPDATA%\Programs\Inno Setup 6\ISCC.exe`. Skript +`installer/setup.iss`; es kopiert die Dateien und ruft danach +`installer/einrichten.bat` auf, das venv, Pakete und Verknüpfungen +anlegt. Norton lässt Inno-Setup-EXEs durch — anders als PyInstaller. +`einrichten.bat` wird **direkt** aufgerufen, nicht über `cmd /c`: dort +scheitern die verschachtelten Anführungszeichen, das venv wurde dann still +nicht angelegt. + +**Updater:** `pruefe_update()` holt beim Start +`https://sva.tyrveil.com/version.json`. Neuere Version → Hinweisbalken +unten. `lade_update()` prüft SHA-256, `spiele_update_ein()` entpackt und +startet einen Hilfsprozess, der nach Programmende die Dateien ersetzt und +neu startet. Nur `https://` wird akzeptiert. Getestet: manipulierte Datei +wird abgelehnt, Dateiersatz funktioniert, `3.9 < 3.10` korrekt. + +`installer/HOCHLADEN.txt` ist die Server-Anleitung für den Nutzer und wird +beim Bau nach `dist/server/` kopiert. `dist/server/` wird bei jedem Bau +gelöscht — nichts von Hand dort ablegen. + +**Einzelschritte**, falls nötig: `werkzeuge/strip.py` entfernt +Kommentare, `werkzeuge/umlaute.py` setzt echte Umlaute. Danach +Zeilenenden vereinheitlichen (`.bat`/`.vbs`/`.txt` als CRLF, `.py` als LF) +und **jede BOM entfernen** — siehe Erkenntnis 7. + +`werkzeuge/umlaute.py` arbeitet über `tokenize` und ersetzt nur in +STRING-Token. Achtung: In Python 3.12+ sind f-Strings **keine** +STRING-Token mehr, die müssen per Textersetzung nachbehandelt werden. + +Weitere Hilfsskripte: `werkzeuge/mictest.py` prüft jedes Audiogerät in +einem eigenen Prozess mit Zeitlimit (ein hängendes Gerät blockiert sonst +alles), `werkzeuge/screenshot.py` nimmt das Fenster inklusive Titelleiste +auf. + +--- + +## 5. Hart erkaufte Erkenntnisse + +Diese Punkte wurden durch Fehlschläge gefunden. Wer sie „aufräumt", baut +die Fehler wieder ein. + +**1 — `pythonw.exe` im venv ist ein Weiterleiter.** +Sie startet intern die Konsolenfassung `python.exe`, wodurch ein +Terminalfenster erscheint. Sie durch eine Kopie der echten `pythonw.exe` +zu ersetzen scheitert ebenfalls: Die Kopie findet ihre `python313.dll` +nicht (die liegt im Python-Ordner). **Lösung:** Die Verknüpfung startet die +echte `pythonw.exe` an ihrem Platz mit `start.pyw` als Argument; +`start.pyw` hängt `.venv\Lib\site-packages` selbst in `sys.path` ein. + +**2 — Ein venv erbt die Tcl/Tk-Pfade nicht.** +`tkinter` findet `init.tcl` nicht und bricht mit `TclError` ab. Deshalb +läuft `_ensure_tcl_paths()` **vor** dem `tkinter`-Import und setzt +`TCL_LIBRARY`/`TK_LIBRARY` aus `sys.base_prefix`. Die ungewöhnliche +Importreihenfolge im Kopf der Datei ist Absicht. + +**3 — Ein venv ist nicht portabel.** +`.venv\pyvenv.cfg` enthält feste Pfade. Auf einem anderen Rechner ist die +Umgebung unbrauchbar. Setup und Fehlersuche prüfen deshalb mit +`python -c "pass"`, ob sie überhaupt startet, und legen sie sonst neu an. +Das Weitergabepaket enthält kein `.venv`. + +**4 — PortAudio-Geräteindizes wandern.** +Sie ändern sich, sobald ein Treiber dazukommt oder verschwindet. Deshalb +wird überall mit dem Anzeigenamen gearbeitet und der Index erst +unmittelbar vor dem Öffnen aufgelöst (`selected_device()`). + +**5 — Windows meldet jedes Gerät über vier Schnittstellen.** +MME, DirectSound, WASAPI, WDM-KS. Beim Nutzer ergab das 18 Einträge für +2 echte Mikrofone. Regeln in `enumerate_inputs()`: +- WASAPI hat Vorrang, dann DirectSound, MME, WDM-KS +- MME kürzt Namen auf 31 Zeichen, deshalb Präfixvergleich in + `gleiches_geraet()` +- WDM-KS wird ausgeblendet, sobald WASAPI etwas liefert — dort erscheinen + Zweitnamen derselben Hardware (`wc19200_8211` war das Focusrite) und + Geräte, die in Windows gar nicht aktiv sind +- Platzhalter wie „Microsoft Soundmapper" werden entfernt +Ein Kontrollkästchen blendet die vollständige Liste wieder ein. + +**6 — Batch: Pipe in `for /f`-Backticks ist unzuverlässig.** +Hat zweimal still Leerwerte geliefert (Größenangabe blieb 0, ein +Prozess-Kill lief ins Leere). PowerShell-Aufrufe in Batch deshalb **ohne +Pipe** schreiben, stattdessen `foreach` mit `if`. + +**7 — PowerShell `-Encoding utf8` erzeugt in Windows PowerShell 5.1 eine BOM.** +VBScript bricht damit sofort ab (`Invalid character`, Zeile 1). Nach jeder +Bearbeitung von `.bat`/`.vbs` prüfen, dass keine BOM vorne steht. + +**8 — Norton 360 verhindert PyInstaller-Builds.** +Der Build bricht mit `Permission denied` ab, unabhängig von Dateiname, +Zielordner und `--onefile`/`--onedir`. Eine fertige EXE wird beim Start +blockiert und gelöscht. Deshalb gibt es **keine EXE**; die Verteilung +läuft über Setup.bat und setzt Python beim Empfänger voraus. Eine +Norton-Ausnahme wäre nötig — das ist eine Sicherheitseinstellung und +bleibt die Entscheidung des Nutzers. + +**9 — Der Windows-Audiodienst kann abstürzen.** +Ist auf diesem Rechner zweimal passiert. Dann scheitert jedes Audiogerät. +`audio_service_running()` prüft das beim Start und weist auf +`net start Audiosrv` hin (braucht Administratorrechte). + +**10 — Squad heißt im Prozess `SquadGame-Win64-Shipping.exe`.** +Verglichen wird per Präfix `SquadGame`. Der frühere Vergleich über den +Fenstertitel war falsch: Er traf auch auf das eigene Programmfenster und +jeden Explorer-Ordner mit „Squad" im Namen zu. + +**11 — Auf diesem Rechner gibt es zwei Python-Installationen.** +`python` zeigt auf die Microsoft-Store-Fassung (3.12), `py` auf die echte +3.13. Die Store-Fassung **virtualisiert `%APPDATA%`** — Zugriffe auf die +Konfigurationsdatei laufen dort ins Leere. Immer den venv-Interpreter +verwenden: `.venv\Scripts\python.exe`. + +**12 — Layout: Die Statusleiste muss vor dem Notebook gepackt werden.** +Mit `side="bottom"`. Sonst nimmt das Notebook (`expand=True`) allen Platz +und die Knöpfe fallen aus dem Fenster. Genau das ist einmal passiert. + +--- + +## 6. Umgebung + +- Windows 11 Pro, kein Git +- Python 3.13.0 unter `%LOCALAPPDATA%\Programs\Python\Python313` +- Norton 360 aktiv, Windows Defender dadurch abgeschaltet +- Audio: Focusrite USB (Hauptmikrofon) und SteelSeries Sonar (virtuell) +- Der Nutzer testet selbst und meldet zurück; er schließt das Fenster oft + zwischendurch — ein fehlender Prozess bedeutet nicht zwingend einen Fehler + +--- + +## 7. Offene Punkte + +**Design steht aus.** Der Nutzer hat mit Claude Design einen Entwurf +gebaut („Board mit bedienbarem Fenster"), der Export kam nie an — die ZIP +lag nicht in `Downloads`. Er soll sie erneut schicken. Der Auftrag dazu +steht in `Design-Briefing.md`: Teil A ein Design System, Teil B die beiden +Bildschirme. Wichtig beim Umsetzen: Was in `ttk` nicht geht (runde Ecken, +Schatten, Verläufe), lässt sich auf einer Zeichenfläche nachbauen — die +Pegelanzeige ist bereits so gelöst. + +**Server-Upload steht aus.** HTTPS auf `sva.tyrveil.com` läuft, aber +`version.json` und die Release-Dateien waren beim letzten Stand noch nicht +hochgeladen (HTTP 404). Der erste echte Durchlauf des Updaters gegen den +Server ist daher noch ungetestet. + +**Installer unsigniert.** Empfänger sehen beim ersten Start die +SmartScreen-Warnung. Abhilfe nur per Code-Signing-Zertifikat. + +**Programm selbst bleibt Python.** Eine gebündelte EXE per PyInstaller +scheitert an Norton (Erkenntnis 8); der Installer setzt Python beim +Empfänger voraus — bewusste Entscheidung des Nutzers. + +--- + +## 8. Arbeitsweise, die sich bewährt hat + +Der Nutzer meldet Symptome, keine Diagnosen („es öffnet sich ein +Konsolenfenster", „so viele Mikrofone"). Mehrfach lag die Ursache woanders +als vermutet, deshalb: **erst messen, dann ändern.** + +Drei Beispiele, in denen Messen die Annahme widerlegt hat: + +- Das Konsolenfenster kam nicht vom Startskript, sondern von einem + Kindprozess. Sichtbar wurde das erst über `ParentProcessId`. +- „Alle Mikrofone scheitern" war kein Gerätefehler, sondern der + abgestürzte Audiodienst — gefunden im Windows-Ereignisprotokoll. +- Eine Prüfung auf sichtbare Konsolenfenster meldete Entwarnung, weil die + Fensterklasse von Windows Terminal fehlte. Der Nutzer sah das Fenster + trotzdem. Ein negativer Testbefund ist kein Beweis. + +Änderungen immer an der **Quelle** vornehmen, dann das Paket neu erzeugen, +dann per `Update.bat` in die Installation bringen — und dort tatsächlich +starten. Ein Syntaxcheck reicht nicht: Mehrere Fehler zeigten sich erst +beim echten Doppelklick. diff --git a/README.md b/README.md new file mode 100644 index 0000000..4e0c87d --- /dev/null +++ b/README.md @@ -0,0 +1,52 @@ +# Squad Voice Activation — Quellordner + +Dies ist das Arbeitsverzeichnis, **nicht** das Paket zum Weitergeben. + +Der Code hier enthält Kommentare und dient der Weiterentwicklung. Das +auslieferbare Paket wird daraus erzeugt und liegt in +`..\Squad Voice Activation 3.1\`. + +## Inhalt + +| Datei | Zweck | +|---|---| +| `squad_voice_activation.py` | Hauptprogramm | +| `start.pyw` | Startskript ohne Konsolenfenster | +| `make_icon.py` | erzeugt `icon.ico` aus `icon.png` | +| `icon.png`, `icon.ico` | Programmsymbol | +| `requirements.txt` | numpy, sounddevice | +| `werkzeuge/` | Hilfsskripte für den Paketbau und Tests | +| `PROJEKT-UEBERGABE.md` | **Technische Dokumentation, hier anfangen** | +| `Design-Briefing.md` | Auftrag für die Gestaltung | + +Die Skripte `Setup.bat`, `Update.bat`, `Deinstallieren.bat`, +`Fehlersuche.bat` und `Starter.vbs` werden **direkt im Paket gepflegt** — +sie durchlaufen keine Aufbereitung und haben deshalb keine Kopie hier. + +## Programm zum Testen starten + +``` +.venv\Scripts\python.exe squad_voice_activation.py +``` + +Immer den Interpreter aus `.venv` verwenden. Auf diesem Rechner zeigt +`python` auf die Microsoft-Store-Fassung, die `%APPDATA%` virtualisiert — +die Konfigurationsdatei wäre dann nicht auffindbar. + +## Paket erzeugen + +``` +.venv\Scripts\python.exe werkzeuge\strip.py squad_voice_activation.py +.venv\Scripts\python.exe werkzeuge\umlaute.py squad_voice_activation.py +``` + +Danach die aufbereiteten Dateien nach `Squad Voice Activation 3.1\Programm\` +kopieren. Einzelheiten und Fallstricke stehen in `PROJEKT-UEBERGABE.md`, +Abschnitt 4. + +Arbeite an einer Kopie, nicht an den Dateien in diesem Ordner — die +Aufbereitung entfernt die Kommentare unwiderruflich. + +## Bedienung des Programms + +Die Anleitung für Endnutzer ist `ANLEITUNG.txt` im Paket. diff --git a/Squad-Voice.png b/Squad-Voice.png new file mode 100644 index 0000000..a9e29b2 Binary files /dev/null and b/Squad-Voice.png differ diff --git a/icon.ico b/icon.ico new file mode 100644 index 0000000..36cbfb9 Binary files /dev/null and b/icon.ico differ diff --git a/icon.png b/icon.png new file mode 100644 index 0000000..a9e29b2 Binary files /dev/null and b/icon.png differ diff --git a/installer/HOCHLADEN.txt b/installer/HOCHLADEN.txt new file mode 100644 index 0000000..a8e915c --- /dev/null +++ b/installer/HOCHLADEN.txt @@ -0,0 +1,88 @@ +================================================================ + Was auf sva.tyrveil.com muss +================================================================ + +Lade diese drei Dateien in das Wurzelverzeichnis der Subdomain: + + version.json + SquadVoiceActivation-3.2.zip + SquadVoiceActivation-Setup-3.2.exe + +Danach müssen diese Adressen erreichbar sein: + + https://sva.tyrveil.com/version.json + https://sva.tyrveil.com/SquadVoiceActivation-3.2.zip + https://sva.tyrveil.com/SquadVoiceActivation-Setup-3.2.exe + + +ZUM VERTEILEN +------------- +Deinen Freunden gibst du nur diesen einen Link: + + https://sva.tyrveil.com/SquadVoiceActivation-Setup-3.2.exe + +Beim ersten Start meldet sich Windows mit "Der Computer wurde durch +Windows geschützt". Das liegt daran, dass die Datei nicht signiert ist, +nicht an einem Fehler. Der Weg: Weitere Informationen -> Trotzdem +ausführen. Sag das am besten gleich dazu. + + +NGINX +----- +Meist genügt die vorhandene Konfiguration. Falls der Download der ZIP +im Browser geöffnet statt gespeichert wird, hilft dieser Zusatz im +server-Block: + + location ~* \.(zip|exe)$ { + add_header Content-Disposition "attachment"; + } + + location = /version.json { + add_header Cache-Control "no-cache"; + default_type application/json; + } + +Die Zeile zu version.json ist die wichtigere: Ohne sie kann ein +zwischengeschalteter Zwischenspeicher noch die alte Versionsnummer +ausliefern, nachdem du längst eine neue hochgeladen hast. + + +WIE DAS UPDATE FUNKTIONIERT +--------------------------- +Das Programm ruft beim Start version.json ab. Steht dort eine höhere +Versionsnummer als die installierte, erscheint unten im Fenster ein +Hinweisbalken mit einer Schaltfläche. Ein Klick lädt die ZIP, prüft die +Prüfsumme, ersetzt die Programmdateien und startet neu. + +Ist der Server nicht erreichbar, passiert schlicht nichts — das +Programm läuft dann ganz normal ohne Hinweis weiter. + + +NEUE VERSION VERÖFFENTLICHEN +---------------------------- +1. In squad_voice_activation.py die Zeile VERSION anpassen +2. Im Quellordner ausführen: + + .venv\Scripts\python.exe werkzeuge\baue_release.py + +3. Den Inhalt von dist\server\ hochladen + +Der Bauvorgang berechnet die Prüfsumme selbst und trägt sie in +version.json ein. Diese Datei niemals von Hand bearbeiten: Stimmt die +Prüfsumme nicht mit der ZIP überein, verweigert das Programm das +Update - genau so ist es gedacht. + +Das Feld "hinweis" darfst du füllen, es erscheint im Hinweisbalken: + + "hinweis": "Mikrofonliste aufgeräumt" + +Halte es kurz, es steht neben der Schaltfläche. + + +WARUM HTTPS PFLICHT IST +----------------------- +Das Programm lädt ausschließlich über HTTPS und lehnt http:// ab. Ein +Updater, der Programmcode über eine unverschlüsselte Verbindung holt, +ließe sich in einem fremden WLAN umleiten - dann käme fremder Code auf +die Rechner deiner Freunde. Die Prüfsumme allein schützt davor nicht, +weil ein Angreifer auch sie mitliefern könnte. diff --git a/installer/einrichten.bat b/installer/einrichten.bat new file mode 100644 index 0000000..de72f3c --- /dev/null +++ b/installer/einrichten.bat @@ -0,0 +1,81 @@ +@echo off +setlocal EnableExtensions +rem Wird vom Installationsprogramm nach dem Kopieren aufgerufen. +rem Legt die Laufzeitumgebung an und erstellt die Verknuepfungen. + +set "SVA_DIR=%~1" +if "%SVA_DIR%"=="" set "SVA_DIR=%~dp0" +if "%SVA_DIR:~-1%"=="\" set "SVA_DIR=%SVA_DIR:~0,-1%" + +set "MITDESKTOP=%~2" +set "STARTMENU=%APPDATA%\Microsoft\Windows\Start Menu\Programs" +set "DESKTOP=%USERPROFILE%\Desktop" + +echo. +echo Richte Laufzeitumgebung ein. Das dauert einen Moment ... +echo. + +py -3 -c "import sys; sys.exit(0 if sys.version_info >= (3,9) else 1)" >nul 2>&1 +if errorlevel 1 ( + echo FEHLER: Python 3.9 oder neuer wurde nicht gefunden. + echo Bitte von https://www.python.org/downloads/ installieren + echo und dabei "Add python.exe to PATH" ankreuzen. + echo Danach dieses Programm erneut installieren. + pause + exit /b 1 +) + +if exist "%SVA_DIR%\.venv\Scripts\python.exe" ( + "%SVA_DIR%\.venv\Scripts\python.exe" -c "pass" >nul 2>&1 + if errorlevel 1 rmdir /s /q "%SVA_DIR%\.venv" +) +if not exist "%SVA_DIR%\.venv\Scripts\python.exe" ( + py -3 -m venv "%SVA_DIR%\.venv" + if errorlevel 1 ( + echo FEHLER: Laufzeitumgebung konnte nicht angelegt werden. + pause + exit /b 1 + ) +) + +"%SVA_DIR%\.venv\Scripts\python.exe" -m pip install --disable-pip-version-check --quiet -r "%SVA_DIR%\requirements.txt" +if errorlevel 1 ( + echo FEHLER: Benoetigte Pakete konnten nicht geladen werden. + echo Besteht eine Internetverbindung? + pause + exit /b 1 +) + +"%SVA_DIR%\.venv\Scripts\python.exe" -c "import os,sys; p=os.path.join(sys.base_prefix,'pythonw.exe'); open(os.path.join(sys.prefix,'basepyw.txt'),'w').write(p if os.path.isfile(p) else '')" +set "BASEPYW=" +if exist "%SVA_DIR%\.venv\basepyw.txt" set /p BASEPYW=<"%SVA_DIR%\.venv\basepyw.txt" +del "%SVA_DIR%\.venv\basepyw.txt" >nul 2>&1 +if not defined BASEPYW set "BASEPYW=%SVA_DIR%\.venv\Scripts\pythonw.exe" + +if exist "%SVA_DIR%\icon.png" "%SVA_DIR%\.venv\Scripts\python.exe" "%SVA_DIR%\make_icon.py" >nul 2>&1 +set "SVA_ICON=%BASEPYW%,0" +if exist "%SVA_DIR%\icon.ico" set "SVA_ICON=%SVA_DIR%\icon.ico" + +powershell -NoProfile -ExecutionPolicy Bypass -Command ^ + "$ws = New-Object -ComObject WScript.Shell;" ^ + "$s = $ws.CreateShortcut('%STARTMENU%\Squad Voice Activation.lnk');" ^ + "$s.TargetPath = '%BASEPYW%';" ^ + "$s.Arguments = '\"%SVA_DIR%\start.pyw\"';" ^ + "$s.WorkingDirectory = '%SVA_DIR%';" ^ + "$s.IconLocation = '%SVA_ICON%';" ^ + "$s.Description = 'Haelt die Sprechtaste, solange du redest';" ^ + "$s.Save()" + +if /i "%MITDESKTOP%"=="desktop" powershell -NoProfile -ExecutionPolicy Bypass -Command ^ + "$ws = New-Object -ComObject WScript.Shell;" ^ + "$s = $ws.CreateShortcut('%DESKTOP%\Squad Voice Activation.lnk');" ^ + "$s.TargetPath = '%BASEPYW%';" ^ + "$s.Arguments = '\"%SVA_DIR%\start.pyw\"';" ^ + "$s.WorkingDirectory = '%SVA_DIR%';" ^ + "$s.IconLocation = '%SVA_ICON%';" ^ + "$s.Description = 'Haelt die Sprechtaste, solange du redest';" ^ + "$s.Save()" + +echo Fertig. +endlocal +exit /b 0 diff --git a/installer/paketdateien/Fehlersuche.bat b/installer/paketdateien/Fehlersuche.bat new file mode 100644 index 0000000..368ba0b --- /dev/null +++ b/installer/paketdateien/Fehlersuche.bat @@ -0,0 +1,58 @@ +@echo off +setlocal +title Squad Voice Activation - Fehlersuche +cd /d "%~dp0" + +echo. +echo Startet das Programm mit sichtbarem Fenster fuer Meldungen. +echo Nur noetig, wenn der normale Start nicht funktioniert. +echo. + +set "PY=.venv\Scripts\python.exe" + +if exist "%PY%" ( + "%PY%" -c "pass" >nul 2>&1 + if errorlevel 1 ( + echo [Setup] Vorhandene Umgebung passt nicht zu diesem Rechner. + echo Sie wird verworfen und neu angelegt. + rmdir /s /q "%~dp0.venv" + ) +) + +if not exist "%PY%" ( + echo [Setup] Erstelle Laufzeitumgebung ... + py -3 -m venv .venv + if errorlevel 1 ( + echo. + echo FEHLER: Python 3 wurde nicht gefunden. + echo Download: https://www.python.org/downloads/ + pause + exit /b 1 + ) + set "NEEDINSTALL=1" +) + +"%PY%" -c "import numpy, sounddevice" >nul 2>&1 +if errorlevel 1 set "NEEDINSTALL=1" + +if defined NEEDINSTALL ( + echo [Setup] Installiere Pakete ... + "%PY%" -m pip install --disable-pip-version-check -r requirements.txt + if errorlevel 1 ( + echo FEHLER: Pakete konnten nicht installiert werden. + pause + exit /b 1 + ) +) + +echo [Start] Squad Voice Activation +"%PY%" squad_voice_activation.py +set "RC=%ERRORLEVEL%" + +if not "%RC%"=="0" ( + echo. + echo Das Programm wurde mit Fehlercode %RC% beendet. +) +echo. +pause +endlocal diff --git a/installer/paketdateien/Starter.vbs b/installer/paketdateien/Starter.vbs new file mode 100644 index 0000000..7ade4ee --- /dev/null +++ b/installer/paketdateien/Starter.vbs @@ -0,0 +1,49 @@ +' Startet das Programm ohne jedes Konsolenfenster. +' Arbeitet ausschliesslich mit Pfaden relativ zu dieser Datei, damit der +' Ordner verschoben oder weitergegeben werden kann. +Option Explicit + +Dim fso, sh, ordner, pakete, cfg, zeile, basis, pyw, bereit +Set fso = CreateObject("Scripting.FileSystemObject") +Set sh = CreateObject("WScript.Shell") + +ordner = fso.GetParentFolderName(WScript.ScriptFullName) +pakete = ordner & "\.venv\Lib\site-packages" +sh.CurrentDirectory = ordner + +' Die pythonw.exe in der virtuellen Umgebung ist nur ein Weiterleiter, der +' intern die Konsolenfassung nachstartet - dabei erscheint ein Fenster. +' Deshalb wird die echte pythonw.exe der Installation gesucht. Ihr Pfad +' steht in pyvenv.cfg unter "home". +basis = "" +If fso.FileExists(ordner & "\.venv\pyvenv.cfg") Then + Dim datei + Set datei = fso.OpenTextFile(ordner & "\.venv\pyvenv.cfg", 1) + Do Until datei.AtEndOfStream + zeile = Trim(datei.ReadLine) + If LCase(Left(zeile, 4)) = "home" Then + basis = Trim(Mid(zeile, InStr(zeile, "=") + 1)) + End If + Loop + datei.Close +End If + +pyw = "" +If basis <> "" And fso.FileExists(basis & "\pythonw.exe") Then + pyw = basis & "\pythonw.exe" +ElseIf fso.FileExists(ordner & "\.venv\Scripts\pythonw.exe") Then + pyw = ordner & "\.venv\Scripts\pythonw.exe" +End If + +bereit = (pyw <> "") _ + And fso.FolderExists(pakete & "\numpy") _ + And fso.FileExists(pakete & "\sounddevice.py") _ + And fso.FileExists(ordner & "\start.pyw") + +If bereit Then + sh.Run """" & pyw & """ """ & ordner & "\start.pyw""", 0, False +Else + ' Umgebung fehlt oder ist unvollstaendig - run.bat richtet sie ein + ' und zeigt dabei bewusst ein Fenster mit Meldungen. + sh.Run """" & ordner & "\run.bat""", 1, False +End If diff --git a/installer/setup.iss b/installer/setup.iss new file mode 100644 index 0000000..05b368e --- /dev/null +++ b/installer/setup.iss @@ -0,0 +1,86 @@ +; Installationsprogramm fuer Squad Voice Activation +; Uebersetzen mit: ISCC.exe setup.iss + +#define Name "Squad Voice Activation" +#define Version "3.2" +#define Herausgeber "tyrveil.com" +#define Website "https://sva.tyrveil.com" + +[Setup] +AppId={{8F3A6C21-5D4E-4B9A-9E7C-2A1B0D6F4E88} +AppName={#Name} +AppVersion={#Version} +AppVerName={#Name} {#Version} +AppPublisher={#Herausgeber} +AppPublisherURL={#Website} +AppSupportURL={#Website} +DefaultDirName={autopf}\SquadVoiceActivation +DefaultGroupName={#Name} +DisableProgramGroupPage=yes +DisableDirPage=no +AllowNoIcons=yes +PrivilegesRequired=lowest +PrivilegesRequiredOverridesAllowed=dialog +OutputDir=..\dist +OutputBaseFilename=SquadVoiceActivation-Setup-{#Version} +SetupIconFile=..\icon.ico +UninstallDisplayIcon={app}\icon.ico +UninstallDisplayName={#Name} +Compression=lzma2 +SolidCompression=yes +WizardStyle=modern +ShowLanguageDialog=no + +[Languages] +Name: "de"; MessagesFile: "compiler:Languages\German.isl" + +[Messages] +de.WelcomeLabel2=Dieses Programm haelt die Sprechtaste in Squad automatisch gedrueckt, solange du redest.%n%nVoraussetzung ist Python 3.9 oder neuer. Fehlt es, wird am Ende ein Hinweis angezeigt. + +[Tasks] +Name: "desktopicon"; Description: "Verknuepfung auf dem Desktop anlegen"; GroupDescription: "Zusaetzliche Verknuepfungen:" + +[Files] +Source: "..\dist\installerdateien\*"; DestDir: "{app}"; Flags: ignoreversion +Source: "einrichten.bat"; DestDir: "{app}"; Flags: ignoreversion + +[Icons] +Name: "{group}\{#Name}"; Filename: "{app}\Starter.vbs"; IconFilename: "{app}\icon.ico" +Name: "{group}\{#Name} deinstallieren"; Filename: "{uninstallexe}" + +[Run] +; Die Batchdatei direkt aufrufen. Der Umweg ueber cmd /c scheitert an den +; verschachtelten Anfuehrungszeichen, sobald der Zielpfad Leerzeichen enthaelt. +Filename: "{app}\einrichten.bat"; Parameters: """{app}"" {code:DesktopWunsch}"; \ + StatusMsg: "Richte Laufzeitumgebung ein, bitte warten ..."; Flags: runhidden waituntilterminated +Filename: "{app}\Starter.vbs"; Description: "{#Name} jetzt starten"; \ + Flags: shellexec nowait postinstall skipifsilent + +[UninstallDelete] +Type: filesandordirs; Name: "{app}\.venv" +Type: filesandordirs; Name: "{app}\__pycache__" +Type: files; Name: "{app}\icon.ico" +Type: files; Name: "{userdesktop}\Squad Voice Activation.lnk" +Type: files; Name: "{userstartmenu}\Squad Voice Activation.lnk" + +[Code] +function DesktopWunsch(Param: String): String; +begin + if WizardIsTaskSelected('desktopicon') then + Result := 'desktop' + else + Result := 'nodesktop'; +end; + +procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep); +var + Auswahl: Integer; +begin + if CurUninstallStep = usPostUninstall then + begin + Auswahl := MsgBox('Sollen auch die gespeicherten Einstellungen entfernt werden?', + mbConfirmation, MB_YESNO); + if Auswahl = IDYES then + DelTree(ExpandConstant('{userappdata}\SquadVoiceActivation'), True, True, True); + end; +end; diff --git a/make_icon.py b/make_icon.py new file mode 100644 index 0000000..c05868b --- /dev/null +++ b/make_icon.py @@ -0,0 +1,147 @@ +""" +Erzeugt icon.ico aus icon.png - ohne Zusatzbibliotheken. + +Liegt keine icon.png vor, wird ein schlichtes Standardsymbol gezeichnet +(Mikrofon mit Schallwellen in den Farben der Oberflaeche). + +Eigenes Symbol verwenden: eine quadratische PNG-Datei mit hoechstens +256 x 256 Bildpunkten als icon.png in diesen Ordner legen und das +Programm neu starten. Fuer die Verknuepfungen zusaetzlich Setup.bat +erneut ausfuehren. +""" + +import struct +import sys +import zlib +from pathlib import Path + +ORDNER = Path(__file__).resolve().parent +PNG = ORDNER / "icon.png" +ICO = ORDNER / "icon.ico" + +GROESSE = 256 +# Farben passend zur Oberflaeche +HINTERGRUND = (30, 35, 27, 255) +RAND = (110, 139, 61, 255) +MIKRO = (156, 186, 92, 255) +WELLE = (217, 164, 65, 255) +LEER = (0, 0, 0, 0) + + +def png_schreiben(pfad, breite, hoehe, pixel): + """Schreibt ein RGBA-Bild als PNG. pixel ist eine Liste von Zeilen.""" + roh = bytearray() + for zeile in pixel: + roh.append(0) # Filtertyp "keiner" + for r, g, b, a in zeile: + roh += bytes((r, g, b, a)) + + def chunk(typ, daten): + return (struct.pack(">I", len(daten)) + typ + daten + + struct.pack(">I", zlib.crc32(typ + daten) & 0xFFFFFFFF)) + + kopf = struct.pack(">IIBBBBB", breite, hoehe, 8, 6, 0, 0, 0) + pfad.write_bytes( + b"\x89PNG\r\n\x1a\n" + + chunk(b"IHDR", kopf) + + chunk(b"IDAT", zlib.compress(bytes(roh), 9)) + + chunk(b"IEND", b"") + ) + + +def standard_symbol(): + """Mikrofon mit zwei Schallbogen, schlicht gehalten.""" + n = GROESSE + mitte = n / 2 + bild = [[LEER for _ in range(n)] for _ in range(n)] + + for y in range(n): + for x in range(n): + dx, dy = x - mitte, y - mitte + r = (dx * dx + dy * dy) ** 0.5 + farbe = LEER + if r <= n * 0.47: + farbe = HINTERGRUND + if n * 0.44 <= r <= n * 0.47: + farbe = RAND + + # Mikrofonkapsel: abgerundetes Rechteck im oberen Bereich + if abs(dx) <= n * 0.10 and -n * 0.28 <= dy <= n * 0.06: + ecke = abs(dy + n * 0.11) - n * 0.11 + if ecke <= 0 or (dx * dx + ecke * ecke) ** 0.5 <= n * 0.10: + farbe = MIKRO + # Buegel unter der Kapsel + if n * 0.15 <= r <= n * 0.19 and dy > 0 and abs(dx) < n * 0.20: + farbe = MIKRO + # Staender und Fuss + if abs(dx) <= n * 0.022 and n * 0.17 <= dy <= n * 0.30: + farbe = MIKRO + if abs(dx) <= n * 0.11 and n * 0.28 <= dy <= n * 0.32: + farbe = MIKRO + # Zwei Schallbogen links und rechts + for radius in (n * 0.27, n * 0.35): + if abs(r - radius) <= n * 0.022 and abs(dy) < abs(dx) * 0.9: + farbe = WELLE + + bild[y][x] = farbe + return bild + + +def png_zu_ico(png_pfad, ico_pfad): + """ + Verpackt ein PNG unveraendert in einen ICO-Behaelter. + + Seit Windows Vista duerfen Symboldateien PNG-Daten direkt enthalten, + das Bild muss also nicht entschluesselt werden. + """ + daten = png_pfad.read_bytes() + if daten[:8] != b"\x89PNG\r\n\x1a\n": + raise ValueError(f"{png_pfad.name} ist keine PNG-Datei.") + breite, hoehe = struct.unpack(">II", daten[16:24]) + if breite > 256 or hoehe > 256: + raise ValueError( + f"{png_pfad.name} ist {breite}x{hoehe} Bildpunkte gross. " + "Zulaessig sind hoechstens 256x256.") + + kopf = struct.pack("=1.26 +sounddevice>=0.4.6 diff --git a/squad_voice_activation.py b/squad_voice_activation.py new file mode 100644 index 0000000..8eeb2ca --- /dev/null +++ b/squad_voice_activation.py @@ -0,0 +1,1623 @@ +""" +Squad Voice Activation +Haelt die Local-VOIP-Taste 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 Voice Activation" +VERSION = "3.2" +CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadVoiceActivation" / "config.json" +LOG_PATH = CONFIG_PATH.parent / "error.log" + + +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_voice_activation.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 VOICE ACTIVATION", + 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()) / "SquadVoiceActivation_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): + 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() diff --git a/start.pyw b/start.pyw new file mode 100644 index 0000000..319b2bc --- /dev/null +++ b/start.pyw @@ -0,0 +1,28 @@ +""" +Startet das Programm ohne Konsolenfenster. + +Hintergrund: Die pythonw.exe innerhalb einer virtuellen Umgebung ist nur +ein Weiterleiter, der intern die Konsolenfassung python.exe nachstartet - +dabei erscheint ein Terminalfenster. Die echte pythonw.exe der +Python-Installation hat dieses Verhalten nicht, kennt aber die Pakete der +virtuellen Umgebung nicht. + +Diese Datei wird deshalb mit der echten pythonw.exe gestartet und haengt +die Pakete der virtuellen Umgebung selbst in den Suchpfad ein. +""" + +import sys +from pathlib import Path + +ORDNER = Path(__file__).resolve().parent + +for pfad in (ORDNER / ".venv" / "Lib" / "site-packages", ORDNER): + if pfad.is_dir(): + eintrag = str(pfad) + if eintrag in sys.path: + sys.path.remove(eintrag) + sys.path.insert(0, eintrag) + +import squad_voice_activation # noqa: E402 + +squad_voice_activation.main() diff --git a/werkzeuge/baue_release.py b/werkzeuge/baue_release.py new file mode 100644 index 0000000..84b5a44 --- /dev/null +++ b/werkzeuge/baue_release.py @@ -0,0 +1,232 @@ +""" +Erzeugt aus der Quelle ein vollstaendiges Release. + +Ergebnis in dist/: + paket/ aufbereitete Programmdateien + SquadVoiceActivation-.zip Paket fuer den Auto-Updater + SquadVoiceActivation-Setup-.exe + version.json Steuerdatei fuer den Server + server/ genau das, was hochgeladen wird + +Aufruf: .venv\\Scripts\\python.exe werkzeuge\\baue_release.py +""" + +import hashlib +import io +import json +import re +import shutil +import subprocess +import sys +import tokenize +import zipfile +from pathlib import Path + +WURZEL = Path(__file__).resolve().parent.parent +DIST = WURZEL / "dist" +BASIS_URL = "https://sva.tyrveil.com" + +PYTHON_DATEIEN = ("squad_voice_activation.py", "start.pyw", "make_icon.py") +MITKOPIEREN = ("requirements.txt", "icon.png", "icon.ico") + +ISCC_KANDIDATEN = ( + Path.home() / "AppData/Local/Programs/Inno Setup 6/ISCC.exe", + Path("C:/Program Files (x86)/Inno Setup 6/ISCC.exe"), + Path("C:/Program Files/Inno Setup 6/ISCC.exe"), +) + +UMLAUTE = [ + ("Aenderung", "Änderung"), ("aendern", "ändern"), ("Geraet", "Gerät"), + ("Haelt", "Hält"), ("haelt", "hält"), ("laesst", "lässt"), + ("laeuft", "läuft"), ("Laeuft", "Läuft"), ("naechst", "nächst"), + ("Praefix", "Präfix"), ("waehl", "wähl"), ("Waehl", "Wähl"), + ("gewaehlt", "gewählt"), ("waehrend", "während"), ("zulaessig", "zulässig"), + ("Zulaessig", "Zulässig"), ("faellt", "fällt"), ("spaeter", "später"), + ("Staender", "Ständer"), ("Behaelter", "Behälter"), ("oeffn", "öffn"), + ("Oeffn", "Öffn"), ("moeglich", "möglich"), ("koenn", "könn"), + ("Koenn", "Könn"), ("loesch", "lösch"), ("noetig", "nötig"), + ("hoeher", "höher"), ("hoechst", "höchst"), ("Menue", "Menü"), + ("Buegel", "Bügel"), ("Stueck", "Stück"), ("drueck", "drück"), + ("Drueck", "Drück"), ("gedrueckt", "gedrückt"), ("zurueck", "zurück"), + ("Zurueck", "Zurück"), ("ueber", "über"), ("Ueber", "Über"), + ("fuer", "für"), ("Fuer", "Für"), ("muess", "müss"), + ("ausfuehr", "ausführ"), ("fuehrt", "führt"), ("unterstuetz", "unterstütz"), + ("gueltig", "gültig"), ("Schluessel", "Schlüssel"), ("ueblich", "üblich"), + ("zusaetzlich", "zusätzlich"), ("pruef", "prüf"), ("Pruef", "Prüf"), + ("Verknuepfung", "Verknüpfung"), ("verknuepf", "verknüpf"), + ("verzoeger", "verzöger"), ("schliess", "schließ"), ("Schliess", "Schließ"), + ("heisst", "heißt"), ("ausser", "außer"), ("Ausser", "Außer"), + ("gross", "groß"), ("Gross", "Groß"), ("weiss", "weiß"), ("Fuss", "Fuß"), + ("Oberflaeche", "Oberfläche"), ("Flaeche", "Fläche"), + ("Abhaengigkeit", "Abhängigkeit"), ("regelmaessig", "regelmäßig"), + ("Verhaelt", "Verhält"), ("Erklaerung", "Erklärung"), + ("standardmaessig", "standardmäßig"), ("hoehe", "höhe"), + ("uebernommen", "übernommen"), ("haengt", "hängt"), + ("abgestuerzt", "abgestürzt"), ("loesst", "löst"), ("Loest", "Löst"), + ("tatsaechlich", "tatsächlich"), ("Haeufige", "Häufige"), + ("Rueckmeldung", "Rückmeldung"), ("geoeffnet", "geöffnet"), + ("kuerzt", "kürzt"), ("laengeren", "längeren"), ("Faerbt", "Färbt"), + ("aelteren", "älteren"), ("massgeblich", "maßgeblich"), + ("Pruefsumme", "Prüfsumme"), ("entschluesselt", "entschlüsselt"), + ("unveraendert", "unverändert"), ("Netzwerkfehler", "Netzwerkfehler"), +] + + +def version_lesen(): + text = (WURZEL / "squad_voice_activation.py").read_text(encoding="utf-8") + treffer = re.search(r'^VERSION\s*=\s*"([^"]+)"', text, re.M) + if not treffer: + raise SystemExit("VERSION nicht gefunden") + return treffer.group(1) + + +def aufbereiten(pfad: Path): + """Kommentare entfernen und echte Umlaute setzen.""" + quelle = pfad.read_text(encoding="utf-8") + + behalten = [t for t in tokenize.generate_tokens(io.StringIO(quelle).readline) + if t.type != tokenize.COMMENT] + text = tokenize.untokenize(behalten) + + zeilen, leer = [], 0 + for zeile in text.split("\n"): + zeile = zeile.rstrip() + leer = leer + 1 if not zeile else 0 + if leer <= 2: + zeilen.append(zeile) + text = "\n".join(zeilen).strip() + "\n" + + tokens = [] + for tok in tokenize.generate_tokens(io.StringIO(text).readline): + if tok.type == tokenize.STRING: + neu = tok.string + for alt, ersatz in UMLAUTE: + neu = neu.replace(alt, ersatz) + tok = tok._replace(string=neu) + tokens.append(tok) + text = tokenize.untokenize(tokens) + + # f-Zeichenketten sind seit Python 3.12 keine STRING-Token mehr + for alt, ersatz in (("uebernommen", "übernommen"), ("geoeffnet", "geöffnet"), + ("ueblichen", "üblichen"), ("Bildpunkte gross", + "Bildpunkte groß")): + text = text.replace(alt, ersatz) + + pfad.write_text(text, encoding="utf-8", newline="\n") + + +def paket_bauen(version): + paket = DIST / "paket" + if paket.exists(): + shutil.rmtree(paket) + (paket / "Programm").mkdir(parents=True) + + for name in PYTHON_DATEIEN: + ziel = paket / "Programm" / name + shutil.copy2(WURZEL / name, ziel) + aufbereiten(ziel) + subprocess.run([sys.executable, "-m", "py_compile", str(ziel)], + check=True, capture_output=True) + for name in MITKOPIEREN: + shutil.copy2(WURZEL / name, paket / "Programm" / name) + + vorlage = WURZEL / "installer" / "paketdateien" + if vorlage.is_dir(): + for datei in vorlage.iterdir(): + shutil.copy2(datei, paket / "Programm" / datei.name) + + for unter in (paket / "Programm").rglob("__pycache__"): + shutil.rmtree(unter, ignore_errors=True) + + # Der Installer legt die Dateien flach ab, der Updater erwartet sie + # unter Programm/. Beides getrennt halten, sonst landet im + # Installationsordner ein ueberfluessiger Unterordner. + flach = DIST / "installerdateien" + if flach.exists(): + shutil.rmtree(flach) + flach.mkdir(parents=True) + for datei in (paket / "Programm").iterdir(): + if datei.is_file(): + shutil.copy2(datei, flach / datei.name) + return paket + + +def zip_bauen(paket, version): + ziel = DIST / f"SquadVoiceActivation-{version}.zip" + if ziel.exists(): + ziel.unlink() + with zipfile.ZipFile(ziel, "w", zipfile.ZIP_DEFLATED) as archiv: + for datei in sorted((paket / "Programm").iterdir()): + if datei.is_file(): + archiv.write(datei, f"Programm/{datei.name}") + return ziel + + +def installer_bauen(version): + iscc = next((p for p in ISCC_KANDIDATEN if p.is_file()), None) + if iscc is None: + print(" Inno Setup nicht gefunden - Installer wird uebersprungen") + return None + skript = WURZEL / "installer" / "setup.iss" + inhalt = skript.read_text(encoding="utf-8") + inhalt = re.sub(r'(#define Version\s+)"[^"]+"', rf'\1"{version}"', inhalt) + skript.write_text(inhalt, encoding="utf-8") + + ergebnis = subprocess.run([str(iscc), str(skript)], + capture_output=True, text=True) + if ergebnis.returncode != 0: + print(ergebnis.stdout[-1500:]) + print(ergebnis.stderr[-1500:]) + raise SystemExit("Installer konnte nicht erstellt werden") + return DIST / f"SquadVoiceActivation-Setup-{version}.exe" + + +def server_bauen(version, zip_pfad, setup_pfad): + server = DIST / "server" + if server.exists(): + shutil.rmtree(server) + server.mkdir(parents=True) + + shutil.copy2(zip_pfad, server / zip_pfad.name) + if setup_pfad and setup_pfad.exists(): + shutil.copy2(setup_pfad, server / setup_pfad.name) + anleitung = WURZEL / "installer" / "HOCHLADEN.txt" + if anleitung.is_file(): + shutil.copy2(anleitung, server / anleitung.name) + + pruefsumme = hashlib.sha256(zip_pfad.read_bytes()).hexdigest() + angaben = { + "version": version, + "datei": f"{BASIS_URL}/{zip_pfad.name}", + "sha256": pruefsumme, + "hinweis": "", + } + (server / "version.json").write_text( + json.dumps(angaben, indent=2, ensure_ascii=False) + "\n", + encoding="utf-8") + return server, pruefsumme + + +def main(): + version = version_lesen() + DIST.mkdir(exist_ok=True) + print(f"Version {version}") + + paket = paket_bauen(version) + print(" Programmdateien aufbereitet") + + zip_pfad = zip_bauen(paket, version) + print(f" {zip_pfad.name} ({zip_pfad.stat().st_size // 1024} KB)") + + setup_pfad = installer_bauen(version) + if setup_pfad: + print(f" {setup_pfad.name} ({setup_pfad.stat().st_size // 1024} KB)") + + server, pruefsumme = server_bauen(version, zip_pfad, setup_pfad) + print(f" server/ vorbereitet, SHA256 {pruefsumme[:16]}...") + print() + print(f"Zum Hochladen bereit: {server}") + + +if __name__ == "__main__": + main() diff --git a/werkzeuge/mictest.py b/werkzeuge/mictest.py new file mode 100644 index 0000000..e2c8bec --- /dev/null +++ b/werkzeuge/mictest.py @@ -0,0 +1,53 @@ +"""Testet jedes Eingabegeraet in einem eigenen Prozess mit Zeitlimit.""" +import subprocess +import sys + +PY = sys.executable + +CHILD = r''' +import sys, numpy as np, sounddevice as sd +dev = int(sys.argv[1]); sr = int(sys.argv[2]) +frames = int(0.7 * sr) +with sd.InputStream(device=dev, channels=1, samplerate=sr, dtype="float32") as s: + data, overflowed = s.read(frames) +rms = float(np.sqrt(np.mean(data**2))); mx = float(np.max(np.abs(data))) +print(f"{rms:.6f} {mx:.6f}") +''' + + +def main(): + import sounddevice as sd + devs = [(i, d) for i, d in enumerate(sd.query_devices()) + if d["max_input_channels"] > 0] + print(f"{'Idx':>4} {'Geraet':44} {'SR':>6} {'Ergebnis'}") + print("-" * 92) + for i, d in devs: + name = d["name"][:42] + sr = 48000 + try: + sd.check_input_settings(device=i, channels=1, samplerate=sr, + dtype="float32") + except Exception: + sr = int(d["default_samplerate"]) + try: + out = subprocess.run([PY, "-c", CHILD, str(i), str(sr)], + capture_output=True, text=True, timeout=6) + except subprocess.TimeoutExpired: + print(f"{i:>4} {name:44} {sr:>6} HAENGT (kein Datenfluss)") + continue + if out.returncode != 0: + err = (out.stderr or "").strip().splitlines() + msg = err[-1][:44] if err else "unbekannter Fehler" + print(f"{i:>4} {name:44} {sr:>6} FEHLER: {msg}") + continue + try: + rms, mx = (float(x) for x in out.stdout.split()) + except Exception: + print(f"{i:>4} {name:44} {sr:>6} unlesbare Ausgabe") + continue + tag = "STILLE (exakt 0)" if mx == 0.0 else f"rms={rms:.5f} max={mx:.5f}" + print(f"{i:>4} {name:44} {sr:>6} {tag}") + + +if __name__ == "__main__": + main() diff --git a/werkzeuge/screenshot.py b/werkzeuge/screenshot.py new file mode 100644 index 0000000..5cc705e --- /dev/null +++ b/werkzeuge/screenshot.py @@ -0,0 +1,48 @@ +"""Nimmt das Fenster inklusive Titelleiste auf.""" +import ctypes +import ctypes.wintypes as wintypes +import subprocess +import sys +import tkinter as tk + +sys.path.insert(0, r"C:\Users\danie\Downloads\Squad_Local_Voice_Activation_v2") +import squad_voice_activation as m + +OUT = (r"C:\Users\danie\AppData\Local\Temp\claude" + r"\C--Users-danie-Downloads-Squad-Local-Voice-Activation-v2" + r"\64d89be0-cffb-4a90-bed0-f23f786b3017\scratchpad\titelleiste.png") + + +class RECT(ctypes.Structure): + _fields_ = [("left", wintypes.LONG), ("top", wintypes.LONG), + ("right", wintypes.LONG), ("bottom", wintypes.LONG)] + + +root = tk.Tk() +m.apply_tactical_theme(root) +app = m.VoiceActivationApp(root) +root.attributes("-topmost", True) +app.current_level = 0.041 + + +def capture(): + root.update_idletasks() + root.update() + hwnd = ctypes.windll.user32.GetParent(root.winfo_id()) or root.winfo_id() + r = RECT() + ctypes.windll.user32.GetWindowRect(wintypes.HWND(hwnd), ctypes.byref(r)) + x, y = r.left, r.top + w, h = r.right - r.left, r.bottom - r.top + ps = ("Add-Type -AssemblyName System.Drawing;" + f"$b = New-Object System.Drawing.Bitmap {w},{h};" + "$g = [System.Drawing.Graphics]::FromImage($b);" + f"$g.CopyFromScreen({x},{y},0,0,$b.Size);" + f"$b.Save('{OUT}');$g.Dispose();$b.Dispose()") + subprocess.run(["powershell", "-NoProfile", "-Command", ps], + capture_output=True) + print("gespeichert:", OUT, f"({w}x{h})") + root.destroy() + + +root.after(2500, capture) +root.mainloop() diff --git a/werkzeuge/strip.py b/werkzeuge/strip.py new file mode 100644 index 0000000..004194b --- /dev/null +++ b/werkzeuge/strip.py @@ -0,0 +1,49 @@ +"""Entfernt Kommentarzeilen, laesst Docstrings und Code unangetastet.""" +import io +import sys +import tokenize + + +def strip_comments(quelle: str) -> str: + ergebnis = [] + tokens = list(tokenize.generate_tokens(io.StringIO(quelle).readline)) + entfernt = 0 + for tok in tokens: + if tok.type == tokenize.COMMENT: + entfernt += 1 + continue + ergebnis.append(tok) + text = tokenize.untokenize(ergebnis) + return text, entfernt + + +def aufraeumen(text: str) -> str: + zeilen = text.split("\n") + raus = [] + for zeile in zeilen: + # Zeilen, die nur noch aus Leerzeichen bestehen, komplett leeren + raus.append("" if not zeile.strip() else zeile.rstrip()) + # hoechstens zwei Leerzeilen hintereinander + kompakt = [] + leer = 0 + for zeile in raus: + if zeile == "": + leer += 1 + if leer > 2: + continue + else: + leer = 0 + kompakt.append(zeile) + while kompakt and kompakt[0] == "": + kompakt.pop(0) + while kompakt and kompakt[-1] == "": + kompakt.pop() + return "\n".join(kompakt) + "\n" + + +if __name__ == "__main__": + pfad = sys.argv[1] + quelle = io.open(pfad, encoding="utf-8").read() + text, anzahl = strip_comments(quelle) + io.open(pfad, "w", encoding="utf-8", newline="\n").write(aufraeumen(text)) + print(f"{pfad}: {anzahl} Kommentare entfernt") diff --git a/werkzeuge/umlaute.py b/werkzeuge/umlaute.py new file mode 100644 index 0000000..d582bc3 --- /dev/null +++ b/werkzeuge/umlaute.py @@ -0,0 +1,99 @@ +"""Setzt echte Umlaute in Zeichenketten und Docstrings. Code bleibt unberuehrt.""" +import io +import re +import sys +import tokenize + +ERSATZ = [ + ("Aenderung", "Änderung"), ("aendern", "ändern"), ("aendert", "ändert"), + ("Aehnlich", "Ähnlich"), ("aehnlich", "ähnlich"), + ("Geraet", "Gerät"), ("geraet", "gerät"), + ("Haelt", "Hält"), ("haelt", "hält"), + ("laesst", "lässt"), ("Laesst", "Lässt"), + ("laeuft", "läuft"), ("Laeuft", "Läuft"), + ("naechst", "nächst"), ("Naechst", "Nächst"), + ("Praefix", "Präfix"), ("praefix", "präfix"), + ("waehl", "wähl"), ("Waehl", "Wähl"), ("gewaehlt", "gewählt"), + ("waehrend", "während"), ("Waehrend", "Während"), + ("zulaessig", "zulässig"), ("Zulaessig", "Zulässig"), + ("faellt", "fällt"), ("Faelle", "Fälle"), + ("erklaert", "erklärt"), ("Qualitaet", "Qualität"), + ("spaeter", "später"), ("Staender", "Ständer"), + ("Behaelter", "Behälter"), ("verfuegbar", "verfügbar"), + ("Anfuehrungszeichen", "Anführungszeichen"), + ("oeffn", "öffn"), ("Oeffn", "Öffn"), + ("moeglich", "möglich"), ("Moeglich", "Möglich"), + ("koenn", "könn"), ("Koenn", "Könn"), + ("loesch", "lösch"), ("Loesch", "Lösch"), + ("noetig", "nötig"), ("Noetig", "Nötig"), + ("hoeher", "höher"), ("Hoeher", "Höher"), + ("hoechst", "höchst"), ("Hoechst", "Höchst"), + ("groess", "größ"), ("Groess", "Größ"), + ("Menue", "Menü"), ("menue", "menü"), + ("Buegel", "Bügel"), ("Stueck", "Stück"), + ("druck", "druck"), + ("drueck", "drück"), ("Drueck", "Drück"), ("gedrueckt", "gedrückt"), + ("zurueck", "zurück"), ("Zurueck", "Zurück"), + ("ueber", "über"), ("Ueber", "Über"), + ("fuer", "für"), ("Fuer", "Für"), + ("muess", "müss"), ("Muess", "Müss"), + ("ausfuehr", "ausführ"), ("Ausfuehr", "Ausführ"), + ("durchfuehr", "durchführ"), ("fuehrt", "führt"), + ("unterstuetz", "unterstütz"), ("Unterstuetz", "Unterstütz"), + ("gueltig", "gültig"), ("Gueltig", "Gültig"), + ("Schluessel", "Schlüssel"), ("ueblich", "üblich"), + ("zusaetzlich", "zusätzlich"), ("Zusaetzlich", "Zusätzlich"), + ("pruef", "prüf"), ("Pruef", "Prüf"), + ("Verknuepfung", "Verknüpfung"), ("verknuepf", "verknüpf"), + ("verzoeger", "verzöger"), ("Verzoeger", "Verzöger"), + ("zueglich", "züglich"), ("Weiterleit", "Weiterleit"), + ("Umgebungsvariable", "Umgebungsvariable"), + ("schliess", "schließ"), ("Schliess", "Schließ"), + ("heisst", "heißt"), ("Heisst", "Heißt"), + ("ausser", "außer"), ("Ausser", "Außer"), + ("gross", "groß"), ("Gross", "Groß"), + ("weiss", "weiß"), + ("Fuss", "Fuß"), + ("Oberflaeche", "Oberfläche"), ("Flaeche", "Fläche"), + ("Abhaengigkeit", "Abhängigkeit"), ("abhaengig", "abhängig"), + ("regelmaessig", "regelmäßig"), ("gemaess", "gemäß"), + ("Bereitschaft", "Bereitschaft"), + ("Verhaelt", "Verhält"), ("verhaelt", "verhält"), + ("Erklaerung", "Erklärung"), + ("Standardmaessig", "Standardmäßig"), ("standardmaessig", "standardmäßig"), + ("Vordergrund", "Vordergrund"), + ("Auswaehl", "Auswähl"), + ("Symbolleiste", "Symbolleiste"), + ("Taskleiste", "Taskleiste"), + ("Woerter", "Wörter"), + ("hoer", "hör"), +] + + +def ersetze(text): + for alt, neu in ERSATZ: + if alt != neu: + text = text.replace(alt, neu) + return text + + +def verarbeite(pfad): + quelle = io.open(pfad, encoding="utf-8").read() + tokens = [] + treffer = 0 + for tok in tokenize.generate_tokens(io.StringIO(quelle).readline): + if tok.type == tokenize.STRING: + neu = ersetze(tok.string) + if neu != tok.string: + treffer += 1 + tok = tok._replace(string=neu) + tokens.append(tok) + io.open(pfad, "w", encoding="utf-8", newline="\n").write( + tokenize.untokenize(tokens)) + return treffer + + +if __name__ == "__main__": + for pfad in sys.argv[1:]: + n = verarbeite(pfad) + print(f" {pfad}: {n} Textbausteine angepasst")