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 <noreply@anthropic.com>
This commit is contained in:
danny 2026-09-10 17:22:54 +02:00
commit f986c3ad11
22 changed files with 3288 additions and 0 deletions

13
.gitattributes vendored Normal file
View file

@ -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

11
.gitignore vendored Normal file
View file

@ -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/

255
Design-Briefing.md Normal file
View file

@ -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.

314
PROJEKT-UEBERGABE.md Normal file
View file

@ -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-<v>.zip`, der Installer
`SquadVoiceActivation-Setup-<v>.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.

52
README.md Normal file
View file

@ -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.

BIN
Squad-Voice.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 28 KiB

BIN
icon.ico Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 28 KiB

BIN
icon.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 28 KiB

88
installer/HOCHLADEN.txt Normal file
View file

@ -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.

81
installer/einrichten.bat Normal file
View file

@ -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

View file

@ -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

View file

@ -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

86
installer/setup.iss Normal file
View file

@ -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;

147
make_icon.py Normal file
View file

@ -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("<HHH", 0, 1, 1)
eintrag = struct.pack("<BBBBHHII",
0 if breite == 256 else breite,
0 if hoehe == 256 else hoehe,
0, 0, 1, 32, len(daten), 22)
ico_pfad.write_bytes(kopf + eintrag + daten)
return breite, hoehe
def finde_png():
"""icon.png hat Vorrang, sonst wird die erste PNG im Ordner genommen."""
if PNG.exists():
return PNG
for kandidat in sorted(ORDNER.glob("*.png")):
return kandidat
return None
def main():
quelle = finde_png()
if quelle is None:
print("Keine PNG-Datei gefunden - zeichne Standardsymbol ...")
png_schreiben(PNG, GROESSE, GROESSE, standard_symbol())
quelle = PNG
print(f" {PNG.name} erstellt ({GROESSE}x{GROESSE})")
elif quelle != PNG:
# Auf den festen Namen bringen, damit Programm und Installer
# das Symbol zuverlaessig finden.
PNG.write_bytes(quelle.read_bytes())
print(f" {quelle.name} als {PNG.name} uebernommen")
try:
breite, hoehe = png_zu_ico(PNG, ICO)
except Exception as fehler:
print(f"FEHLER: {fehler}")
return 1
print(f" {ICO.name} erstellt aus {PNG.name} ({breite}x{hoehe})")
return 0
if __name__ == "__main__":
sys.exit(main())

2
requirements.txt Normal file
View file

@ -0,0 +1,2 @@
numpy>=1.26
sounddevice>=0.4.6

1623
squad_voice_activation.py Normal file

File diff suppressed because it is too large Load diff

28
start.pyw Normal file
View file

@ -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()

232
werkzeuge/baue_release.py Normal file
View file

@ -0,0 +1,232 @@
"""
Erzeugt aus der Quelle ein vollstaendiges Release.
Ergebnis in dist/:
paket/ aufbereitete Programmdateien
SquadVoiceActivation-<v>.zip Paket fuer den Auto-Updater
SquadVoiceActivation-Setup-<v>.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()

53
werkzeuge/mictest.py Normal file
View file

@ -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()

48
werkzeuge/screenshot.py Normal file
View file

@ -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()

49
werkzeuge/strip.py Normal file
View file

@ -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")

99
werkzeuge/umlaute.py Normal file
View file

@ -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")