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

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