Release alpha 10 with bilingual UI and social co-op

Record manual Netcup website deployment
Document direct deployment and add safe Nakama helper
2026-10-10 12:50:27 +02:00 · 2026-10-09 23:53:32 +02:00 · 2026-10-09 23:34:42 +02:00 · 2026-10-09 15:04:09 +02:00 · 2026-10-06 23:59:12 +02:00 · 2026-10-06 18:34:49 +02:00
42 changed files with 3051 additions and 320 deletions
@@ -1,6 +1,6 @@
 # Void Bastion – Alpha-Testcheckliste

-Diese Liste wird vor jeder öffentlichen Windows-Alpha vollständig abgearbeitet. Automatische Prüfungen sind mit **A**, manuelle Sicht- und Bedienprüfungen mit **M** gekennzeichnet.
+Diese Liste wird fortlaufend erweitert und vor jeder öffentlichen Version abgearbeitet. Automatische Prüfungen sind mit **A**, manuelle Sicht- und Bedienprüfungen mit **M** gekennzeichnet. Neue Wünsche werden hier ergänzt; Punkte werden erst nach erfolgreicher Prüfung abgehakt.

 ## Build und Installation

@@ -15,7 +15,7 @@ Diese Liste wird vor jeder öffentlichen Windows-Alpha vollständig abgearbeitet
 ## Darstellung und Bedienung

 - [ ] **M** 1920 × 1080, 2560 × 1440 und eine kleinere 16:9-Auflösung prüfen: Karte und UI bleiben scharf und vollständig sichtbar.
- [ ] **M** Alle drei Karten prüfen: Straße, Gegnerlaufweg, Raster und Bausperren stimmen exakt überein.
+- [ ] **M** Alle sieben Karten prüfen: Straße, Gegnerlaufweg, Raster und Bausperren stimmen exakt überein.
 - [ ] **M** Reaktoren und freie Weltraumbereiche sind auf allen Karten unbebaubar.
 - [ ] **M** Reichweitenvorschau erscheint vor dem Bau; Turmwerte und Upgrade-Mehrwert sind lesbar.
 - [ ] **M** Zurück-Schaltfläche bricht eine laufende Runde verständlich ab.
@@ -38,9 +38,68 @@ Diese Liste wird vor jeder öffentlichen Windows-Alpha vollständig abgearbeitet
 - [ ] **M** Kurzen Netzabbruch während einer Onlinepartie und die Wiederverbindung prüfen.
 - [ ] **M** Lokaler Koop mit KI: getrennte Ressourcen, zwei Gegnerwege, Seitenwechsel und gemeinsames Reaktorleben prüfen.

+## Sprache und Freundesliste
+
+- [x] **A** Deutsch/Englisch-Umschaltung und Freundes-/Einladungszustände bestehen den Godot-Test.
+- [x] **A** Serverprüfung lehnt Einladungen ohne gegenseitige Freundschaft oder Raumhoheit ab und begrenzt Wiederholungen.
+- [ ] **M** Nach Client- und Server-Update beide Sprachen vollständig durchspielen; ältere Status- und Fehlermeldungen nachübersetzen.
+- [ ] **M** Auf zwei Konten Freundschaftsanfrage senden, annehmen und wieder entfernen; Status „online“ und „im Spiel“ samt Wiederverbindung prüfen.
+- [ ] **M** Aus einem privaten Raum eine Einladung senden und auf dem zweiten Gerät direkt beitreten; nach Raumende darf kein alter Code mehr nutzbar sein.
+- [x] **A** Datenschutzhinweise für Freundschaftsbeziehungen, Status und Systemeinladungen aktualisiert und auf der öffentlichen Seite geprüft.
+
 ## Veröffentlichung

- [ ] **M** Setup-Datei und SHA-256-Prüfsumme stimmen mit der öffentlichen Release-Datei überein.
- [ ] **M** Download-Schaltfläche auf `https://void-bastion.gergames.de/` lädt die aktuelle Setup-Datei.
+- [x] **A** Alpha-10-Setup-Datei und SHA-256-Prüfsumme stimmen mit dem erneut heruntergeladenen Gitea-Release-Asset überein.
+- [x] **A** Der Homepage-Release-Endpunkt zeigt auf Alpha 10 und die aktuelle Setup-Datei; Download-Schaltfläche im Browser noch manuell anklicken.
 - [ ] **M** Datenschutz, Impressum, Supportadresse und Kontolöschseite sind öffentlich erreichbar.
- [ ] **M** Änderungen, bekannte Fehler und Testhinweise stehen in den Release-Notizen.
+- [x] **A** Änderungen, bekannte Fehler und Testhinweise stehen in den Alpha-10-Release-Notizen.
+
+## Neue offene Punkte (Stand 06.10.2026)
+
+- [ ] **M** Android-APK auf einem echten Android-Handy installieren und Start, Touch-Steuerung, verschiedene Bildschirmformate, App-Wechsel/Fortsetzen und Performance prüfen. Bisheriger erfolgreicher Start war nur im Emulator.
+- [ ] **A/M** Android-Audiofehler beheben: Laufzeit-generierte Audioeffekte sind auf Android derzeit deaktiviert; importierte Audioassets einsetzen und auf echtem Gerät prüfen.
+- [ ] **A/M** Android-AdMob-Einbindung prüfen: Beim Test wurde das native AdMob-Modul nicht gefunden; Testanzeigen erst nach erfolgreicher Integration und Einwilligungsprüfung aktivieren.
+- [ ] **A** Android-Release-Pipeline erstellen: signierter Release-Build/AAB, sichere Ablage des Signierschlüssels und fortlaufender `versionCode`. Export-Presets stehen jetzt auf Code 2; das vorhandene APK ist weiterhin der alte Debug-Testbuild mit Code 1. Export des neuen APK wartet auf den Java-SDK-Pfad in Godot.
+- [ ] **M** Schwierigkeit neu balancieren: aktuell schafft der Entwickler alle Karten auf allen Schwierigkeitsstufen problemlos. Schwerpunkt ist **Schwer**, ohne Leicht/Mittel unfair zu machen.
+- [ ] **A/M** Weitere Gegnerschiffe mit klar unterscheidbaren Rollen, visueller Silhouette und passenden Kontern entwerfen, implementieren und gegen alle sechs Türme testen.
+- [ ] **M** Online-Koop mit zwei echten Geräten vollständig spielen; Emulator-/Integrationstests ersetzen diesen Test nicht.
+- [ ] **M** Datenschutzhinweise, Store-Datenerklärungen und Kontolöschung vor einer öffentlichen Store-Veröffentlichung final prüfen.
+
+## Abarbeitung am 06.10.2026
+
+- [x] Drei zusätzliche Gegnertypen mit eigener Grafik und Daten angelegt: schneller Abfangjäger, dauerhafter Schildkreuzer und schwerer Belagerer.
+- [x] Gegnertypen kommen wellenabhängig ins Spiel; auf Schwer erscheinen sie früher (Abfangjäger ab Welle 3, Schildkreuzer ab 5, Belagerer ab 8). Bosswellen verwenden den Belagerer.
+- [x] Schwer startet jetzt mit 340 Energie und 12 Reaktorleben; die Belohnung beträgt 12 Kernkristalle. Gegnerzahl und Gegnerhülle ziehen ab der Missionsmitte zusätzlich an.
+- [x] Automatisierter Godot-Smoke-Test besteht (`VOID_BASTION_SMOKE_TEST_OK`); Windows-Testexport wurde erstellt.
+- [x] Nakama-Laufzeitsimulation besteht (`VOID_BASTION_SERVER_SIM_OK`).
+- [ ] **A** Windows-Testexport war erfolgreich, meldete aber `app_icon.png` als ungültige Icon-Datei; vor dem nächsten Installer-/Store-Build das Iconformat prüfen und reparieren.
+- [ ] Manuelle Spieltests für Schwierigkeitsbalance und alle neuen Gegner bleiben offen; die automatisierten Tests beweisen noch nicht, dass Schwer in echten Läufen fair und fordernd ist.
+- [ ] Android-Testbuild mit den neuen Änderungen noch nicht exportiert: Godot meldet, dass `export/android/java_sdk_path` leer ist. Das JDK ist unter `C:\Program Files\Android\Android Studio\jbr` vorhanden; in Godot unter Editor-Einstellungen > Export > Android als Java-SDK-Pfad setzen, dann Export erneut ausführen. Das vorhandene Emulator-APK ist noch älter; ein echter Android-Gerätetest steht ebenfalls aus.
+
+## Gegnervielfalt und Balance
+
+- [x] **A** Drei Bodeneinheiten ergänzt: schneller Rover, Sturmpanzer und Belagerungsläufer; Werte enthalten Lebenspunkte, Tempo, Reaktorschaden und Belohnung.
+- [x] **A** Türme besitzen Luft-/Boden-Zielklassen; Plasma und Railgun treffen beide Kategorien mit reduziertem Schaden.
+- [x] **A** Aktuelle und nächste Welle werden im HUD mit Luft-/Bodensymbolen, kleinen Einheitengrafiken und Anzahlen angezeigt.
+- [x] **A** Die Vorschau zeigt die Gesamtzahl der Schiffe und lesbare Stückzahlen neben den Gegnerminiaturen.
+- [x] **A** Lasertreffer bauen ein separates Schild-Lebenskonto ab; der blaue Schutzring zeigt den verbleibenden Anteil gegen den Uhrzeigersinn an und Überschussschaden trifft die Hülle.
+- [x] **A** Lokaler Entwicklungsmultiplikator für Gegner-Lebenspunkte (0,5×–3,0×) ist über F9 und die +/- Schaltflächen einstellbar; Online-Koop bleibt davon unabhängig.
+- [x] **A** Entwicklermodus kann den Kristallstand in 25er-Schritten erhöhen oder senken und speichert den Teststand.
+- [ ] **M** Neue Luft- und Bodentypen im laufenden Spiel visuell prüfen: Silhouetten, Trefferreaktionen, Flug-/Bodenbewegung und Zielauswahl der Türme.
+- [ ] **M** Die neuen leuchtend grünen Bodenfahrzeuge im Spiel und in der Wellenvorschau auf Lesbarkeit bei kleiner Darstellung prüfen.
+- [ ] **M** Turmprioritäten erste/letzte/MEISTE HP/SCHILD testen; Laser muss bei mehreren Zielen immer ein erreichbares Schildziel vor ungeschützten Zielen wählen.
+- [ ] **M** Bei einem Schildgegner den Laser einsetzen und prüfen, dass der blaue Ring sichtbar gegen den Uhrzeigersinn schrumpft und erst danach der überschüssige Schaden die Hülle trifft.
+- [ ] **M** Pro Gegnertyp Konter und Werte im Spiel prüfen: Lebenspunkte, Tempo, Schild/Resistenz, Reaktor-Schaden, Belohnung und passende Türme.
+- [ ] **M** Alle sieben Karten auf Leicht, Mittel und Schwer vollständig testen und Schwierigkeit, Ressourcen, Gegnerzusammensetzung sowie Sieg-/Niederlagenquote protokollieren.
+- [ ] **M** Schwer muss spürbar fordernd sein, aber mit sinnvoller Strategie schaffbar; Leicht und Mittel bleiben fair abgestuft.
+- [ ] **A/M** Wellenmischung je Schwierigkeit testen; Schwierigkeit soll nicht allein durch mehr Lebenspunkte entstehen.
+- [ ] **M** Testläufe mit Siegquote, Reaktorleben und verwendeten Türmen festhalten; Balance iterativ nach den Ergebnissen anpassen.
+- [ ] **M** Gegner-Stärkemultiplikator für Entwicklung verwenden, Testwert notieren und vor dem Release auf 1,0× zurücksetzen.
+
+## Android-Test und Store-Vorbereitung
+
+- [ ] **M** Auf echtem Gerät: Installation, erster Start, Touch-Bauen/Upgraden/Verkaufen, Wellen, Pause, Zurück, App-Wechsel und erneutes Öffnen prüfen.
+- [ ] **M** Auf kleinem und großem Display prüfen, dass Spielfeld und Bedienelemente erreichbar und nicht abgeschnitten sind.
+- [ ] **M** Android-Audio auf echtem Gerät prüfen; bis dahin bleibt die Android-spezifische Audiodeaktivierung bestehen.
+- [ ] **M** Android-Testanzeigen erst freigeben, wenn das native Plugin geladen wird, Anzeigen sichtbar sind und Datenschutz-/Einwilligungsablauf geprüft wurde.
+- [ ] **M** Google-Play-internen Test mit signiertem AAB durchführen; Release-Schlüssel geschützt und außerhalb des Repositories verwahren.
@@ -50,6 +50,28 @@ Color palette: dark titanium, worn steel, deep red markings, red-orange emissive
 Constraints: genuinely transparent background, no labels, no text, no logos, no watermark, no cropped parts, no perspective tilt
 ```

+## Neue Gegnerschiffe (Balance-Iteration)
+
+Die Rollenbilder liegen separat, damit die zusätzlichen Schiffe trotz unterschiedlicher Silhouette ohne Sprite-Sheet-Cropping angezeigt werden: `enemy_interceptor.png`, `enemy_shield_carrier.png` und `enemy_siege_destroyer.png`. Alle drei zeigen die Flugrichtung nach rechts; der Laufcode dreht das jeweilige Bild passend zur Route. Quelle: integrierter OpenAI-Bildgenerator, transparenter Hintergrund, Stilreferenz war `enemy_ships.png`.
+
+**Abfangjäger** — schnell, schmal, geringe Hülle und höherer Reaktorschaden bei Durchbruch.
+
+```text
+Einzelner transparenter feindlicher Abfangjäger für Void Bastion, scharf-winklige schmale Flügel, vollständig sichtbar und nach rechts ausgerichtet (Bug rechts, Triebwerke links), verwitterte gunmetal- und rote Panzerplatten, orange Triebwerke, realistischer 3D-gerenderter Top-down-3/4-Sci-Fi-Spielgrafikstil passend zum bestehenden Gegner-Sprite, keine Umgebung, kein Text, kein Rahmen, kein Wasserzeichen.
+```
+
+**Schildkreuzer** — mittelgroß, dauerhaft abgeschirmt und mit blau-cyanfarbenen Emittern deutlich erkennbar.
+
+```text
+Einzelner transparenter feindlicher Schild-Unterstützer für Void Bastion, breite kompakte Silhouette, cyanfarbene Energie-Emitter-Ringe und leuchtender Kern direkt im Schiff, keine äußere Schutzblase, vollständig sichtbar und nach rechts ausgerichtet, verwitterte gunmetal- und rote Panzerplatten, realistische 3D-gerenderte Sci-Fi-Spielgrafik passend zum bestehenden Gegner-Sprite, keine Umgebung, kein Text, kein Rahmen, kein Wasserzeichen.
+```
+
+**Belagerer** — schweres, langsames Schiff mit breiter Silhouette und hohem Reaktorschaden; wird außerdem für Bosswellen genutzt.
+
+```text
+Einzelner transparenter schwerer feindlicher Belagerungszerstörer für Void Bastion, breite massive gepanzerte Silhouette mit mehreren sichtbaren Kanonen und drei starken orangefarbenen Triebwerken, vollständig sichtbar und nach rechts ausgerichtet, verwitterte gunmetal- und rote Panzerplatten, realistischer 3D-gerenderter Sci-Fi-Spielgrafikstil passend zum bestehenden Gegner-Sprite, keine Umgebung, kein Text, kein Rahmen, kein Wasserzeichen.
+```
+
 ## app_icon.png

 ```text
@@ -0,0 +1,21 @@
+# Vollständiges Projekt-Backup
+
+- Erstellt: 2026-10-06
+- Quelle: `C:\Users\Domin\Documents\Codex\2026-10-02\ich\outputs\void-bastion`
+- Enthält den gesamten Projektordner inklusive `.git`-Historie, Assets, Godot-Importdaten, Plattformprojektordner, lokalen Builds und Installerdateien.
+- Startpunkt für die Wiederaufnahme: `PROJEKT-HANDBUCH-FORTSETZUNG.md` und danach `README.md`.
+- Das Backup ist eine Sicherheitskopie. Änderungen darin nicht als Arbeitskopie verwenden; zuerst in einen normalen Projektordner zurückkopieren.
+- Nicht enthalten sind Geheimnisse/Zugangsdaten, die ausschließlich auf Unraid, im Webhosting oder in einem Passwortmanager liegen.
+
+## Prüfsumme prüfen
+
+Nach dem Kopieren lassen sich wichtige Dokumente und Builds mit PowerShell vergleichen:
+
+```powershell
+Get-FileHash -Algorithm SHA256 .\PROJEKT-HANDBUCH-FORTSETZUNG.md
+Get-FileHash -Algorithm SHA256 .\project.godot
+Get-FileHash -Algorithm SHA256 .\build\android\Void-Bastion-Android-x64-alpha4.apk
+Get-FileHash -Algorithm SHA256 .\dist\Void-Bastion-Setup-x64.exe
+```
+
+Die Ausgabe dieser Befehle muss für Quelldatei und Sicherung identisch sein.
@@ -0,0 +1,63 @@
+# Void Bastion: Git- und Serververöffentlichung
+
+Stand: 10. Oktober 2026. Diese Anleitung enthält bewusst keine Passwörter, privaten Schlüssel, Webhook-Adressen oder API-Tokens.
+
+## Zuständigkeiten
+
+| Teil | Quelle | Ziel | Transport |
+|---|---|---|---|
+| Homepage und geschützte Statistikseite | `outputs/void-bastion-website-git` | Gitea `Emporex/Void-Bastion-Website` → Netcup `gergames.de/void-bastion` | Git über repositorygebundenen SSH-Deploy-Key; Netcup-Plesk-Git-Anbindung |
+| Online-Spielserver/Nakama | `outputs/void-bastion/server/nakama/runtime/build/index.js` | Unraid `/mnt/user/appdata/void-bastion-online/nakama/modules/build/index.js` | bestehender SSH-Alias `unraid-codex`, `tools/deploy-nakama.ps1` |
+| Windows-Spiel | Godot-Projekt `outputs/void-bastion` | Gitea-Release mit Setup-EXE; Homepage verlinkt neuestes Release | separater Windows-Build-/Release-Prozess |
+
+Die Website und der Nakama-Server sind unterschiedliche Systeme. Ein Git-Push zur Website aktualisiert nicht automatisch den Heimserver. Ein Nakama-Upload aktualisiert nicht automatisch Netcup.
+
+## Website: direkt per Git arbeiten
+
+Der aktuelle Arbeitsklon ist `outputs/void-bastion-website-git`. Sein `origin` zeigt per SSH auf Port 2202 des lokalen Unraid-Gitea. In der **lokalen** `.git/config` steht `core.sshCommand` mit dem repositorygebundenen Schlüssel `C:/Users/Domin/.ssh/id_ed25519_void_bastion_site` und der separat geprüften Host-Key-Datei `known_hosts_void_bastion_gitea`. Der private Schlüssel ist nicht im Repository. Der Gitea-Schlüssel hat Schreibrechte **nur** für `Emporex/Void-Bastion-Website`. Er ist auf diesem PC ohne Passphrase gespeichert und durch die Windows-Dateirechte auf Benutzer, Administratoren und System begrenzt. Ein laufender SSH-Agent ist hierfür nicht nötig. Bei Verlust des PCs den Deploy-Key in Gitea widerrufen.
+
+```powershell
+cd 'C:\Users\Domin\Documents\Codex\2026-10-02\ich\outputs\void-bastion-website-git'
+git pull --ff-only
+git status
+# Nur beabsichtigte Dateien bearbeiten und gezielt stagen, z. B.:
+git add intern/statistik/index.php
+git commit -m "Beschreibung der Änderung"
+git push origin main
+```
+
+Vor jedem Push `git status` und `git diff --cached` prüfen. Keine Zugangsdaten committen. `intern/statistik/stats-config.local.php` bleibt ausschließlich auf dem Webhosting und ist in `.gitignore` ausgeschlossen.
+
+Netcup-Plesk ist mit dem Gitea-Repository `Emporex/Void-Bastion-Website`, Branch `main`, und dem Ziel `/gergames.de/void-bastion` verbunden. Seit dem 10. Oktober steht der Plesk-Bereitstellungsmodus auf **Automatisch**. Im Gitea-Repository ist der aktive Webhook „Plesk – Void Bastion Website“ eingerichtet: nur Push-Events, Branch-Filter `main`, POST mit `application/json`. Seine Plesk-Zieladresse enthält einen Zugriffswert und darf weder in Git noch in diese Doku kopiert werden. Ein Test-Event und der echte Push von Commit `3502e04` erhielten jeweils HTTP 204. Der harmlose HTML-Kommentar dieses Commits war danach auf der öffentlichen Homepage sichtbar, ohne manuelle Plesk-Aktion. Damit reicht künftig für Website-Änderungen der geprüfte `git push origin main`; anschließend die betroffene Live-Seite prüfen. Die Windows-Versionsanzeige kommt separat über `latest-release.php` aus der Releases-API und beweist keine PHP-Bereitstellung.
+
+Falls eine Änderung nicht live erscheint: In **diesem** Gitea-Repository unter Einstellungen → Webhooks die jüngste Zustellung und Antwort prüfen. In Plesk nur bei `void-bastion.gergames.de` den Git-Stand und das Bereitstellungsziel prüfen; notfalls dort „Jetzt Pull ausführen“ und „Jetzt bereitstellen“ manuell nutzen. Andere Domains oder das webhostingweite FTP/SSH-Konto nicht für automatische Uploads benutzen. Ein unerwünschtes Website-Update durch einen gezielten Git-Revert und erneuten Push zurücknehmen, nicht durch Änderungen an fremden Domains.
+
+Ein künftiger Wechsel des PCs benötigt den lokalen privaten Schlüssel aus einem sicheren Backup **oder** einen neu ausgestellten Deploy-Key auf Gitea. Vor der ersten Verbindung den Gitea-SSH-Host-Key erneut mit dem am Server veröffentlichten Schlüssel vergleichen (derzeit ED25519-Fingerabdruck `SHA256:WFM5G2yjTwTlJqF8OmBqx4N2O4/8L35vJ4Qu4zrC/J0` für `[192.168.178.20]:2202`). Die vollständige Verzeichnisstruktur und lokale `.git/config` lassen sich nicht allein aus einem Quellcode-ZIP wiederherstellen.
+
+## Nakama: prüfen und gezielt veröffentlichen
+
+Im Godot-Projektordner:
+
+```powershell
+& '.\tools\deploy-nakama.ps1'
+& '.\tools\deploy-nakama.ps1' -Apply
+```
+
+Ohne `-Apply` läuft zuerst der Server-Simulationstest und dann ein SHA-256-Vergleich; es wird nichts hochgeladen. Mit `-Apply` lädt das Skript nur bei einer Änderung hoch, prüft den Hash, sichert die bisherige Serverdatei mit Zeitstempel, ersetzt sie, startet **nur** den Nakama-Container neu und wartet auf dessen `healthy`-Status. Bei einem Fehler nach der Aktivierung nicht blind erneut starten; zuerst Logs prüfen und bei Bedarf die gemeldete Sicherungsdatei wiederherstellen. Der Unraid-SSH-Zugang ist serverweit mächtig: Pfade und Containername im Skript nicht ohne Prüfung ändern.
+
+Am 10. Oktober 2026 wurde für Alpha 10 das Server-Bundle mit SHA-256 `1b0a0922a1a289d7bb1ccf12269732ea57853eab9f60353757656a7c0fdd0917` aktiviert; Nakama meldete `healthy` und der Zwei-Konten-Test für Freundschaft, Status und Einladung bestand. Die RPCs `create_unlock_code`, `list_unlock_codes` und `invite_friend` sind registriert. Die PHP-Codeverwaltung aus Gitea-Commit `3e6132e` wurde am 9. Oktober manuell auf Netcup bereitgestellt; danach wurde die automatische Website-Bereitstellung eingerichtet und getestet.
+
+## Windows-Release und Homepage
+
+Den Windows-Export mit `packaging/windows/build.ps1` erstellen und die exportierte EXE vor dem Upload mit `--headless --quit` starten. Das Skript benötigt den Godot-Konsolenpfad und optional `-MakeNsisExe` mit der **echten** NSIS-Binärdatei (auf diesem PC `C:\Users\Domin\AppData\Local\Programs\NSIS-3.13\Bin\makensis.exe`; die gleichnamige Datei eine Ebene höher ist nur ein Starter). Produkt-, Installer- und Projektversion gemeinsam erhöhen. Das Skript gibt Größe und SHA-256 des Setups aus.
+
+Im öffentlichen Gitea-Repository `Emporex/Void-Bastion-Releases` zuerst einen **Entwurf** für den neuen Tag erstellen, dann `Void-Bastion-Setup-x64.exe` anhängen. Den hochgeladenen Entwurf mit den über Git Credential Manager gespeicherten Zugangsdaten erneut herunterladen und SHA-256 vergleichen. Erst danach den Entwurf veröffentlichen. Keine Zugangsdaten oder Token in Skripte, Dateien oder Chat kopieren. Der vorhandene Gitea-Token hat `write:repository`, aber kein `read:user`; ein `GET /api/v1/user` kann deshalb trotz funktionierendem Release-Zugriff 403 liefern.
+
+Die Website liest den neuesten **veröffentlichten** Release mit passendem EXE-Asset automatisch über `https://void-bastion.gergames.de/latest-release.php`; der Ingame-Updater liest die Release-Liste. `.../releases/latest` ist zur Alpha-Prüfung ungeeignet, da Gitea Vorabversionen dort nicht berücksichtigt. Nach jeder Veröffentlichung beide tatsächlichen Endpunkte und den öffentlichen Download testen. Alpha 10: `v0.1.0-alpha.10`, Setup SHA-256 `8B86ABC1EBF95252BD5C3C08156B9DD92BE6585A47E9DA323043D6483FED7287`.
+
+## Absicherung und Wiederherstellung
+
+- Keine Zugangsschlüssel in Git, Doku, Chat oder Build-Artefakte kopieren.
+- Git-Push über den Website-Deploy-Key und Server-Upload über `unraid-codex` sind bewusst getrennt.
+- Für die Website bleiben die geschützte lokale PHP-Konfiguration und die Netcup-Git-Zuordnung auf Netcup; ein Git-Klon allein ist kein vollständiges Hosting-Backup.
+- Für Nakama gehören PostgreSQL-Backups und die Server-Konfiguration in das bestehende Unraid-Backup. Das Deploy-Skript sichert nur die bisherige JavaScript-Datei, nicht die Datenbank.
@@ -28,6 +28,10 @@ Nach jeder erfolgreichen Anmeldung meldet der Client Plattform und App-Version a

 Die Serverfunktion `private_stats` ist ausschließlich über den geheimen Nakama-HTTP-Schlüssel für die geschützte, nicht verlinkte Statistikseite der Homepage erreichbar. Angemeldete Spielclients können diese Werte nicht abrufen. Der geheime Schlüssel bleibt auf Unraid und im privaten Webhosting-Verzeichnis; er wird weder exportiert noch im Repository gespeichert.

+Die geschützte Statistikseite kann außerdem Freischaltcodes für alle Türme, alle Karten oder beides erstellen. `create_unlock_code` ist nur Server-zu-Server mit dem Nakama-HTTP-Schlüssel verfügbar. Codes werden über ihren SHA-256-Schlüssel nachgeschlagen; zusätzlich liegt der Klartextcode für die geschützte Admin-Übersicht in einem privaten Nakama-Speicherobjekt mit `permissionRead:0` und `permissionWrite:0`. Das Spiel kann diese Objekte nicht lesen. `list_unlock_codes` liefert Code, Freischaltumfang, optionale Bemerkung, Erstellungszeit und Einlösungszähler ausschließlich für Server-zu-Server-Aufrufe zurück. Die Statistikseite zeigt daraus „Offen“, „Teilweise eingelöst“ oder „Eingelöst“; die Bemerkung ist optional und auf 160 Zeichen begrenzt. Hinweise können z. B. Empfänger beschreiben und sollten keine unnötigen privaten Daten enthalten. Bereits vor dieser Erweiterung erzeugte Codes behalten ihren Status, aber ihr Klartext kann nicht rekonstruiert werden.
+
+Pro Konto gelten höchstens zehn Codeversuche in fünf Minuten. Die Spieler lösen Codes im Menü über `redeem_unlock_code` ein; die Freischaltungen liegen am Onlinekonto und werden nach einer Anmeldung über `get_promo_unlocks` wiederhergestellt. Für die Codeverwaltung müssen sowohl das Nakama-Runtime-Bundle als auch die PHP-Statistikseite aktualisiert werden. Der Nakama-HTTP-Schlüssel bleibt ausschließlich auf Unraid und im privaten Webhosting-Verzeichnis.
+
 Im Hauptmenü ist eine Ranglistenansicht für die aktuell gewählte Karte und Schwierigkeit eingebaut. Sie zeigt Mission und Endlosmodus getrennt, löst aktuelle öffentliche Profilnamen auf und hebt den eigenen Eintrag hervor.

 ## Multiplayer
@@ -38,6 +42,12 @@ Vor dem Start zeigt eine gemeinsame Lobby beide Pilotennamen und ihre zugewiesen

 Der autoritative Matchserver verwaltet Spielerplätze, getrennte Energie, Türme, Gegner, Wellen und die gemeinsamen Reaktorleben. Beide Clients erhalten denselben geprüften Spielzustand. Der lokale KI-Koop bleibt unabhängig davon spielbar.

+## Sprache und Freunde (in Entwicklung)
+
+Unter **Einstellungen** kann zwischen Deutsch und Englisch gewechselt werden. Die Wahl liegt in der lokalen Datei `user://void_bastion_settings.cfg` und bleibt nach einem Neustart erhalten. Hauptmenü, Kartenwahl, Koop- und Freundesbereich sowie die wichtigsten Spiel-, Shop- und Ergebnisansichten sind übersetzt. Einzelne ältere Status- und Fehlermeldungen können noch auf Deutsch erscheinen; vor einer internationalen Veröffentlichung ist ein vollständiger Sprachdurchlauf nötig.
+
+Die Freundesliste verwendet die Nakama-Freundschaftsfunktionen: Eine Anfrage wird über die eindeutige Spielerkennung gesendet und muss von der anderen Seite angenommen werden. Nur bestätigte Freunde zeigen Online- bzw. Im-Spiel-Status. Der Status ist grob (`menu` oder `playing`), ohne Karten-, Wellen- oder Standortdaten. Ein privater Raum kann nur vom Raumersteller an bestätigte Freunde eingeladen werden. Die Serverfunktion `invite_friend` prüft Raum und Freundschaft, begrenzt wiederholte Einladungen und sendet eine flüchtige Systembenachrichtigung mit Raumcode. Es gibt keinen Chat und keinen frei formulierten Nachrichtentext. Für diese Funktion müssen Client und Nakama-Runtime gemeinsam auf den neuen Stand gebracht werden; sie ist mit dem lokalen Test allein noch nicht live.
+
 ## Adressen

 - Produktion: `https://api.void-bastion.gergames.de` und `wss://api.void-bastion.gergames.de`
@@ -50,7 +60,14 @@ Die öffentliche Freischaltung ist abgeschlossen: Der autoritative DNS-Eintrag `
 ## Tests

 - Offline-/Gameplaytest: `godot --headless --path . --script res://tests/smoke_test.gd`
+- Online-Zustands-/Interpolationstest ohne Server: `godot --headless --path . res://tests/online_snapshot_test.tscn`
 - echter Onlinetest im Heimnetz: `godot --headless --path . --script res://tests/online_integration_test.gd`
 - Produktionstest: `VOID_BASTION_TEST_HOST=api.void-bastion.gergames.de VOID_BASTION_TEST_SCHEME=https VOID_BASTION_TEST_PORT=443 godot --headless --path . --script res://tests/online_integration_test.gd`

 Der Onlinetest prüft zwei Gastanmeldungen, Änderung und Ablehnung von Spielernamen, die Löschung eines eigens erzeugten Wegwerf-Testkontos, RPC, Ergebnisannahme, Ranglistenabruf, zwei WebSocket-Verbindungen, schnelles Matchmaking, die Bereit-Lobby, autoritative Spielzustände sowie Erstellen, Verlassen und Wiederbeitreten eines privaten Raums per Code.
+
+Bei einem stockenden Onlinespiel schreibt der Client alle zehn Sekunden eine Zeile `ONLINE DIAG` ins Godot-Protokoll: Anzahl und maximale Lücke der Zustandspakete, Lücken über 500 ms, größte Paketgröße, maximale JSON-Lese- und Zustandsanwendungszeit. Zusätzliche Zeilen melden Bildaussetzer über 200 ms und WebSocket-Abbruch/Wiederverbindung. Eine große Paketlücke bei normaler Bildrate deutet auf Übertragung oder Server hin; eine lange Bildlücke ohne Paketlücke eher auf den Client. Für eine Fehlermeldung möglichst die Zeilen direkt vor und nach dem Hänger sichern; Spielerkennungen und Zugangsdaten werden darin nicht ausgegeben.
+
+Der Client fasst bei Rückstau maximal fünf eingetroffene Spielstände zusammen: Nur der neueste Zustand wird angewendet, die Schusseffekte dieser wenigen Pakete bleiben erhalten. Ältere, verworfene Zustände sind nur noch historische Zwischenbilder. `coalesced` in `ONLINE DIAG` zählt die dabei übersprungenen Zustände. Weg- und Baufeldgeometrie wird nur beim Karten- bzw. Arenenwechsel neu berechnet. Der lokale Snapshot-Test prüft außerdem, dass Geschosse nach einem langen Bildaussetzer ihr Ziel erreichen und verschwinden.
+
+Der Server meldet mit `ONLINE DIAG tick_gap_ms` verspätete Match-Ticks über 250 ms und mit `ONLINE DIAG loop_ms` eine Verarbeitung über 70 ms. Die Meldungen enthalten nur Ticknummer und Objektanzahl. Wenn beim Client Paketlücken auftreten, aber zur gleichen Zeit keine Tick- oder Loop-Warnung auf dem Server, liegt die Suche als Nächstes bei WebSocket-Verbindung und Reverse Proxy.
@@ -0,0 +1,191 @@
+# Void Bastion – Projekt- und Fortsetzungs-Handbuch
+
+Stand: 9. Oktober 2026 · Version: 0.1.0-alpha.4 · Engine: Godot 4.7.2
+
+Dieses Dokument ist die zentrale technische Übergabe für die Weiterarbeit an Void Bastion – auch nach einem PC-Wechsel. Es beschreibt den aktuellen Stand, die Projektstruktur und die verbindlichen Gestaltungs- und Datenregeln. Bei Änderungen immer zuerst diese Datei, `README.md`, `ART_ASSETS.md` und die Tests lesen.
+
+## Projektziele und aktueller Stand
+
+Void Bastion ist ein 2D-Tower-Defense-Spiel im realistischen Science-Fiction-Stil für Windows, Android und später iOS. Der aktuelle Spielstand ist Alpha 4. Einzelspieler mit sieben Karten, sechs Türmen, drei Schwierigkeitsstufen, 15 Wellen plus optionalem Endlosmodus, Shop, lokalem Profil und Bestenlisten ist vorhanden. Ein lokaler Koop-Modus gegen KI sowie eine Nakama-Onlineanbindung sind vorbereitet/implementiert.
+
+Wichtige Einschränkungen des aktuellen Android-Teststands:
+
+- Der Android-Emulator (Android 17, x86_64, SwiftShader) startet Alpha 4 und bleibt mindestens 45 Sekunden aktiv. Der Bildschirm zeigt das Hauptmenü; im Log gab es während dieses Laufs keinen Absturz.
+- Android verwendet den Mobile/Vulkan-Renderer. Die GLES-Compatibility-Variante überschritt auf dem Emulator die verfügbare Shader-Uniform-Grenze.
+- Wegen eines reproduzierbaren nativen SIGSEGV in Androids AudioTrack/OpenSL-Ausgabepfad sind Musik und UI-Klicktöne derzeit nur auf Android deaktiviert. Windows-Audio bleibt aktiv. Vor dem Wiederaktivieren erst mit regulären, eingebundenen Audioassets und auf echten Geräten erneut testen.
+- Im Android-Log meldet das AdMob-Plugin, dass sein natives Singleton nicht initialisiert ist. Android-Werbung ist deshalb nicht als funktionsfähig getestet anzusehen.
+- Die geprüfte Emulator-Datei ist `build/android/Void-Bastion-Android-x64-alpha4.apk`. Sie hat die Paketkennung `de.gergames.voidbastion`, Versionsnamen `0.1.0-alpha.4` und ist mit dem lokalen Debug-Schlüssel signiert. Sie ist nur zum Sideload-/Emulator-Test bestimmt, nicht zur Store-Veröffentlichung.
+- Es wurde kein echtes Android-Handy in diesem Testlauf geprüft. Touch-Bedienung, Geräteperformance, verschiedene Seitenverhältnisse, Anzeigen und Audio brauchen noch echte Gerätetests.
+
+## Projektdateien und Zuständigkeiten
+
+- `project.godot`: Godot-Projekt, Fenster-/Viewport-Einstellungen, Autoloads, Editor-Plugins und Renderer. Desktop bleibt auf `gl_compatibility`; Mobilgeräte nutzen derzeit `mobile`/Vulkan.
+- `main.gd`: Spielzustand, Karten-/Weg-/Bau-/Turmdaten, Wellen, KI, Kampf, UI, Zeichnen und lokale Navigation. Die zentralen Datenkonstanten stehen am Dateianfang.
+- `main.tscn`: Hauptszene und Manager-Nodes.
+- `multiplayer_manager.gd`: lokale Koop-/KI-Regeln und Multiplayer-Helfer.
+- `online_manager.gd`, `account_manager.gd`: Nakama-Verbindung, Profil, Anmeldung und Ranglisten.
+- `ads_manager.gd`: Werbeintegration. Testmodus beibehalten, bis Konten, Einwilligung und Store-Konfiguration rechtlich/technisch geprüft sind.
+- `update_manager.gd`: Prüft öffentliche Releases und bietet einen Update-Link an; installiert nichts ungefragt.
+- `assets/`: Kartenbasen, Turm-/Gegnersprites, Straßenmaterial und UI-Grafiken.
+- `tests/smoke_test.gd`: Offline-/Logikregressionstest. Nach Karten-, Weg-, Turm-, Wellen- oder Balancingänderungen immer ausführen.
+- `tests/online_integration_test.gd`: Nakama-/Onlineintegrationstest; nur gegen ausdrücklich gewählte Testumgebung ausführen.
+- `packaging/windows/build.ps1` und `packaging/windows/installer.nsi`: Windows-Export und Setup-Installer.
+- `export_presets.cfg`: Windows-, Android- und iOS-Exportprofile.
+- `server/nakama/`: Serverkonfiguration/Module. Keine Servergeheimnisse hier ablegen.
+- `README.md`, `ART_ASSETS.md`, `ONLINE_SETUP.md`, `LEGAL_RELEASE_CHECKLIST.md`, `PLATFORM_ACCOUNT_SETUP.md`, `THIRD_PARTY_NOTICES.md`: ergänzende Projektunterlagen.
+- `.godot/`, `build/`, `dist/`, `android/build/`: generierte Imports, Builds, Caches und Artefakte. Sie gehören zum vollständigen PC-Backup, aber normalerweise nicht in Git-Commits.
+
+## Karten: verbindliche Regeln
+
+### Koordinatensystem und Raster
+
+- Die logische Spielfläche ist `SCREEN = Vector2(1600, 900)` in `main.gd`.
+- `GRID_SIZE = 80` Pixel; Karten, Wege, Bauzellen und Turm-Snapping müssen mit demselben Raster arbeiten.
+- Das Rasterzentrum eines Feldes liegt bei `(40 + 80·x, 40 + 80·y)`. Wegpunkte sollen auf diesen Feldmitten liegen. Der auslaufende Start darf links bei `x = -40` liegen.
+- Wegsegmente verlaufen nur waagerecht oder senkrecht. Keine diagonalen Segmente. Kurven entstehen durch aufeinanderfolgende rechtwinklige Segmente.
+- Gegnerrouten und Straßenzeichnung beziehen ihre Daten gemeinsam aus `MAP_PATHS`/`path_cells`. Niemals zusätzlich einen unabhängigen Weg in die Hintergrundgrafik malen oder eine zweite separate Laufroute definieren.
+
+### Drei parallele Kartendatenlisten
+
+Jeder Karteneintrag muss denselben Index in ALLEN folgenden Arrays besitzen (in `main.gd`):
+
+1. `MAP_TEXTURES`: Hintergrundtextur.
+2. `MAP_NAMES`, `MAP_DESCRIPTIONS`, `MAP_UNLOCK_COSTS`: Name, Kurzbeschreibung und Shoppreis.
+3. `MAP_PATHS`: geordnete Mittellinienpunkte für Gegner und Straße.
+4. `MAP_BUILD_ZONES`: erlaubte Deckbereiche als ein oder mehrere `Rect2`-Rechtecke.
+5. `MAP_REACTOR_ZONES`: Reaktormittelpunkt(e) und Sperrradius/-radien.
+
+Alle Listen müssen dieselbe Kartenanzahl und identische Reihenfolge haben. Nach Hinzufügen oder Umsortieren einer Karte die Anzahl und Reihenfolge prüfen und Smoke-Test ergänzen.
+
+### Routenende, Reaktor und Bauverbote
+
+- Letzter Punkt in `MAP_PATHS[index]` muss exakt im Mittelpunkt des Hauptreaktors landen (Toleranz in `_validate_route_ends_at_reactor()` ist 1 Pixel). `_select_map()` validiert die Route; der Smoke-Test validiert alle Karten.
+- Die Reaktorgrafik im Hintergrund, `MAP_REACTOR_ZONES[index][0].center` und letzter Wegpunkt müssen optisch/technisch deckungsgleich sein.
+- Auf jedem Reaktor ist Bauen verboten. Alle Reaktoren/offenen Reaktorkammern derselben Karte in `MAP_REACTOR_ZONES` eintragen. Pyrax hat zusätzlich die offene Reaktorkammer als zweite Sperrzone.
+- Erlaubte Deckzellen werden über `MAP_BUILD_ZONES` definiert. Das Spiel sperrt zusätzlich Wegzellen, Reaktorzonen, Randzellen und bereits belegte Zellen.
+- Türme werden auf Feldmitten eingerastet. Weder Türme noch Wegkacheln sollen nur über Bildkoordinaten korrigiert werden: zuerst Raster-/Routendaten korrigieren.
+
+### Kartengrafik
+
+- Karte ist eine saubere, hochauflösende Draufsicht im Querformat (bestehende HD-Basen etwa 3344×1882 Pixel).
+- Hintergrundgrafik ohne eingebauten Weg, Fahrbahn, Raster, Bauplätze, Türme, Gegner, UI, Text oder Logos erstellen. Straße/Raster/Route werden im Spiel gezeichnet; so können sie nicht gegeneinander verrutschen.
+- Der Reaktor soll gut erkennbar am rechten Rand ungefähr auf Höhe des Spielfeldzentrums liegen, außer die Route/Zone definiert absichtlich eine andere Lage.
+- Behalte realistische aktive Stationsbeleuchtung, Metallpaneele, Cyan-Energieelemente und kleine warme Positionslichter. Keine dunkle/ausgewaschene Karte und keine starke gelbe Umrandung der kompletten Straße.
+- Die Straße ist eine Rasterzelle breit (80 px) und nutzt `road_straight.svg`, `road_corner.svg`, `road_surface_material_v1.png`, `road_corner_surface_v1.png`.
+- Der letzte Abschnitt zum Reaktor wird in `_draw_reactor_approach()` mit leisem Lichtimpuls und langsamem Transparenzverlauf gestaltet. Den Schluss nicht hart abschneiden und keine groben Doppelbögen ans Reaktorzentrum setzen.
+- Asset-Prompts und Asset-Herkunft in `ART_ASSETS.md` dokumentieren.
+
+### Kartenprüfung
+
+1. Für jeden Wegpunkt Rastermitte prüfen, horizontale/vertikale Segmente sicherstellen.
+2. Ende exakt am Reaktormittelpunkt kontrollieren.
+3. Reaktor im Hintergrund mit Sperrzone vergleichen; keine Bauzellen auf dem Reaktor.
+4. Das Projekt starten: Weg muss sichtbar mit Gegnerlaufspur, Raster und Hintergrund zusammenpassen.
+5. Zwischen Wegen müssen Bauzellen frei bleiben, soweit sie innerhalb einer Build-Zone und außerhalb aller Route-/Reaktor-Sperren liegen.
+6. `tests/smoke_test.gd` für jede neue Karte um Routenende, Reactor-Sperre, baubare Zellen und Shop-Kosten erweitern und ausführen.
+
+## Türme und Gegner
+
+### Turmdaten und Darstellung
+
+Die Liste `TOWER_DATA` in `main.gd` ist die zentrale Quelle für Turmname, Baukosten, Basisschaden, Reichweite, Schussintervall (`rate`, Sekunden pro Schuss), Projektilgeschwindigkeit, Schadensart, Farbe, Freischaltpreis und Beschreibung. Schüsse/Sekunde wird aus dem Intervall berechnet. Beim Hinzufügen eines Turms müssen UI-Karte, Shop, Platzierung, Reichweitenvorschau, Angriff/Schadenslogik, Upgrade, Speichern/Freischaltung und Tests konsistent ergänzt werden.
+
+Sprites:
+
+- Kinetik, Laser, Rakete: drei horizontale Frames aus `assets/defense_towers.png`.
+- Plasma, EMP-Puls, Railgun: separate Texturen (`tower_plasma.png`, `tower_emp.png`, `tower_railgun.png`).
+- Ergänzende Sprites im bestehenden maßstäblichen Top-Down-Stil und mit transparenter Fläche erzeugen. In `_draw_tower()` Textur/Fall ergänzen. Bei der Kinetik-Ausrichtung beachten, dass ein falscher Basiswinkel den Lauf um 180° verdreht erscheinen lässt.
+
+| Turm | Kosten | Schaden | Reichweite | Intervall | Besonderheit |
+|---|---:|---:|---:|---:|---|
+| Kinetik | 120 EN | 22 | 190 | 0,55 s | Einzelziel |
+| Laser | 180 EN | 12 | 165 | 0,18 s | Schnell, effektiv gegen Schilde |
+| Rakete | 250 EN | 65 | 260 | 1,40 s | Flächenschaden 76 |
+| Plasma | 230 EN | 48 | 240 | 1,05 s | Flächenschaden 92; 18 Kernkristalle Freischaltung |
+| EMP-Puls | 210 EN | 34 | 215 | 0,92 s | Flächeneffekt 118; 24 Kernkristalle |
+| Railgun | 300 EN | 110 | 330 | 1,85 s | Durchschlägt Schild; 30 Kernkristalle |
+
+Alle Türme unten in der Leiste darstellen. Reichweite schon vor dem Bauen zeigen; Vorschaukasten kompakt/transluzent halten. Turminfo soll Schaden, Schüsse pro Sekunde, Reichweite und Einzel-/Flächentyp zeigen. Upgrade-Vorschau muss den echten Zuwachs darstellen und darf keine verdeckten Felder erzeugen. Bei Balancingänderungen Shoptext und Tests mit anpassen.
+
+### Gegner
+
+Gegnerwerte liegen in `ENEMY_DATA`: Jäger (70 HP, Tempo 105, Belohnung 18), Fregatte (185 HP, Tempo 72, Belohnung 34), Kreuzer (520 HP, Tempo 43, Belohnung 78). Skalierung und Wellenlogik werden zusätzlich durch `DIFFICULTY_DATA`/Wellenfunktionen beeinflusst. Schildgegner sollen Laserschaden bevorzugt wirksam bekommen; andere Türme dürfen reduziert, aber nicht grundsätzlich null Schaden verursachen. Railgun ignoriert den Schildschutz.
+
+## Wellen, Wirtschaft, Highscore
+
+- `MAX_WAVES = 15`; Bossgegner alle fünf Wellen.
+- Leicht entspricht dem früheren Balancing, Mittel/Schwer steigern Lebenspunkte, Tempo und Gegneranzahl und reduzieren Startressourcen. Belohnung aktuell 5/7/10 Kernkristalle nach Schwierigkeit.
+- Nach Welle 15 gibt es die Wahl: Mission beenden oder freiwillig Endlosmodus. Endlos-Verlust gilt nicht als gescheiterte Mission.
+- Punkte sollen neben erreichter Welle auch Restenergie und effiziente Turmverwendung abbilden. Verkauf aller Türme in der Schlusswelle darf keinen Multiplikator-Trick ermöglichen; deshalb Turmbau-/Verkaufshistorie berücksichtigen, nicht nur die am Ende noch stehenden Türme.
+- Spielwährung heißt konsistent **Kernkristalle** (nicht abwechselnd „Kern“ oder „Kristalle“). Energie/EN ist die missionsinterne Bauressource.
+- Für neue Türme/Karten Shopfreischaltungen und Belohnung konsistent speichern; kein echter Geldeinkauf ist für diese Testfassung erforderlich.
+
+## Multiplayer
+
+- Lokale KI-Arena verwendet `COOP_LEFT_PATH` und eine Spiegelung exakt um die Achse durch den gemeinsamen Reaktor (`COOP_MIRROR_X = 1480`). Weltbreite ist doppelt; beide Seiten sollen voll groß bleiben, nicht zusammengeschrumpft.
+- Reaktorleben sind gemeinsam, Credits getrennt; jeder baut auf seiner Seite. KI-Platzierung in `_find_ai_build_position()` anhand echter Gegnerroute und effektiver Turmreichweite bewerten, niemals zufällige/off-route Plätze wählen.
+- Onlinekonten, Räume, Ranglisten und Ergebnisprüfung laufen über Nakama. Niemals Admin-/Server-/HTTP-Schlüssel in Godot-Projekt, `.env`-Beispiel, Git, Website oder diese Anleitung kopieren.
+- Server-/Unraid-Konfiguration und öffentliche Adresse sind in `ONLINE_SETUP.md` bzw. `server/nakama/README.md` beschrieben; echte Geheimnisse liegen nur auf dem Server/Webhosting.
+
+## Builds, Checks und Release
+
+### Logiktest
+
+```powershell
+& 'E:\Program Files\Godot\Godot_v4.7.2-stable_win64_console.exe' --headless --path . --script tests/smoke_test.gd
+```
+
+Erfolg endet mit `VOID_BASTION_SMOKE_TEST_OK`. Bekannte Umgebungswarnungen zum CA-Zertifikat oder user://-Log sind nicht automatisch ein Spielfehler; entscheidend ist Rückgabecode und Ergebnis.
+
+### Windows-Installer
+
+```powershell
+& '.\packaging\windows\build.ps1' `
+  -GodotExe 'E:\Program Files\Godot\Godot_v4.7.2-stable_win64_console.exe' `
+  -MakeNsisExe '.\build\nsis-portable\nsis-3.13\makensis.exe'
+```
+
+Artefakt: `dist/Void-Bastion-Setup-x64.exe`. Das Skript blendet das Entwicklungs-MCP aus dem Release aus, exportiert und stellt anschließend `project.godot` wieder her.
+
+### Android
+
+- Godot Exportprofil heißt `Android Studio Emulator x86_64` (emulator) bzw. `Android Test APK` (ARM64/ARMv7-Geräte).
+- Erfordert Android SDK, Java 17, Gradle und Godot-Android-Templates. Android-Paketkennung ist `de.gergames.voidbastion`.
+- Das Editor-MCP-Autoload/Plugin darf nicht ins Release gelangen: temporär vor dem Export `_MCPGameBridge` und `res://addons/agent_tools/plugin.cfg` aus der Exportkopie entfernen und Quelldatei danach wiederherstellen (Windows-Skript zeigt das sichere try/finally-Muster). Nie eine Änderung versehentlich dauerhaft aus der Entwicklerdatei löschen.
+- Emulator Alpha 4 wurde mit Gradle 8.11.1, AGP 8.6.1, Java 17 und SDK 36 gebaut. Bei einem Gradle `AccessDeniedException` in einer Transform-Cache-Datei neues separates `GRADLE_USER_HOME` nutzen; vorhandene Cache-Datei nicht blind löschen.
+- Für einen Testbuild prüfen: `aapt dump badging` zeigt `de.gergames.voidbastion` und `0.1.0-alpha.4`; `apksigner verify --verbose` muss `Verifies` melden; danach auf Emulator installieren und mindestens 45 Sekunden starten, Logcat auf SIGSEGV/FATAL prüfen und Screenshot kontrollieren.
+- Erfolgreiche Testdatei liegt in `build/android/Void-Bastion-Android-x64-alpha4.apk` (Debugsignatur; nur intern). APK ist im Git-Verlauf nicht garantiert; im Vollbackup enthalten.
+- Für neue Google-Play-/Sideload-Versionen Android `versionCode` erhöhen. Signaturschlüssel für Produktion getrennt und sicher aufbewahren, nicht Debugschlüssel als Store-Schlüssel verwenden.
+
+### iOS und Stores
+
+iOS-Export erzeugt ein Xcode-Projekt, erfordert macOS, Xcode, Zertifikate/Provisioning und ein Apple-Developer-Konto. Ein Windows-Rechner kann die iOS-App nicht final signieren oder in den App Store hochladen. Google Play-/Apple Store-/Steam-Accounts, Datenschutz- und Storefreigaben bleiben manuelle Betreiberaufgaben. Vor öffentlichem Release Checklisten/Third-party-Lizenzen und echte Geräteprüfung abschließen.
+
+### Webseite und Releases
+
+Homepage: `https://void-bastion.gergames.de/`. Öffentliche Releases/Setup liegen im separaten Gitea-Releases-Projekt; der Ingame-Updater fragt die Release-API ab und soll automatisch das neueste passende Setup/APK verlinken. Nach einer Veröffentlichung Release-Tag, Version in Godot, Windows Installer, Android versionCode und Release-Assetnamen synchron halten. Keine Websiteänderung ist erforderlich, wenn Release-API/Assets korrekt gepflegt sind.
+
+### Netcup-Dateiübertragung
+
+Der aktuelle, schnellere Git-/SSH-Ablauf für Website und Nakama steht in `DEPLOYMENT-SCHNELLWEG.md`. Diese Datei bei Veröffentlichungen zuerst lesen. Der Website-Quellcode wird lokal per repositorygebundenem SSH-Deploy-Key nach Gitea gepusht; Nakama wird unabhängig davon per SSH gezielt auf Unraid aktualisiert.
+
+- Die Website `void-bastion.gergames.de` liegt im Netcup-Webspace unter `gergames.de/void-bastion`. Änderungen nur in diesem Domain-/Ordnerbereich vornehmen; andere gehostete Seiten sind ausdrücklich außerhalb des Arbeitsumfangs.
+- Beim Prüfen des Netcup-Panels am 9. Oktober 2026 zeigte der FTP-Bereich nur das Hauptkonto `hosting143098` mit Basisverzeichnis `/`. Das ist ein webhostingweiter Zugang und darf nicht für automatisierte Void-Bastion-Uploads verwendet werden, weil er auch andere Websites erreichen kann.
+- Laut Netcup-Dokumentation lässt sich kein zusätzlicher FTP-Benutzer anlegen; zur Verfügung steht der SSH-Zugang. Ein separater, auf Void Bastion beschränkter FTP-Benutzer existiert daher nicht.
+- Für automatisierte Übertragungen zuerst prüfen, ob SFTP über den vorhandenen SSH-Zugang aktiviert ist und ob dessen Startverzeichnis sicher auf den benötigten Webspace begrenzt ist. Bis Host, Port, Authentifizierung und zulässiger Zielpfad praktisch bestätigt sind, nichts automatisiert hochladen.
+- Zugangsdaten oder private SSH-Schlüssel niemals in dieses Repository oder diese Anleitung schreiben. Für die Einrichtung nach Möglichkeit einen eigenen SSH-Schlüssel verwenden und nur lokal/geschützt speichern. Das bestehende Git-Deployment bzw. der Netcup-Dateimanager bleiben sichere Alternativen, bis SFTP getestet wurde.
+- Passwörter, private Schlüssel und API-Tokens niemals in diese Anleitung, Git oder Projektdateien schreiben. Geheimnisse separat im Passwortmanager bzw. geschützten lokalen Credential Store des Betreibers ablegen. In der Anleitung dürfen nur Host, Protokoll, Port, Benutzername und begrenzter Zielpfad stehen, sofern diese Werte bestätigt wurden.
+
+## Weiterarbeit nach einem PC-Wechsel
+
+1. Backupordner auf neuen PC kopieren und vorzugsweise in einen stabilen Arbeitsordner legen.
+2. Git installieren; `git status` und `git log -1` prüfen. Den mitgesicherten `.git`-Ordner nicht entfernen, damit die Historie erhalten bleibt.
+3. Godot 4.7.2 installieren und `project.godot` importieren; ersten Assetimport abwarten.
+4. `PROJEKT-HANDBUCH-FORTSETZUNG.md`, `README.md`, `ART_ASSETS.md`, `ALPHA_TEST_CHECKLIST.md`, `ONLINE_SETUP.md` lesen.
+5. Android-Buildtools/JDK 17 nur einrichten, wenn Android gebraucht wird. Emulator neu anlegen; lokale Gradle-Caches und lokale Godot-Einstellungen sind maschinengebunden und können auf dem neuen PC neu erzeugt werden.
+6. `tests/smoke_test.gd` ausführen, dann Spiel im Editor starten und zuletzt Plattformbuilds prüfen.
+7. Serverzugänge, Signierzertifikate, echte AdMob-/Nakama-Schlüssel und Hostingpasswörter separat aus einem Passwortmanager/Server sichern. Diese sind absichtlich nicht Teil des Repositories oder dieser Anleitung.
+
+## Grundsatz bei jeder Karten-/Turmänderung
+
+Eine visuelle Änderung ist erst fertig, wenn Datenquelle, Darstellung, Kollisions-/Bauprüfung, Kauf-/Freischaltstatus, UI-Text und automatisierter Test zueinander passen. Bei Karten besonders Route, Straßenkacheln, Raster, Bauflächen, Sperrzonen und Reaktorhintergrund gemeinsam prüfen. Keine unabhängige „optische Reparatur“ über die Route zeichnen.
@@ -16,9 +16,16 @@ Ein plattformübergreifender 2D-Tower-Defense-Prototyp für Godot 4. Der aktuell
 - jede geeignete Plattformzelle ist bebaubar; ausschließlich Wegzellen, Reaktoren und Bereiche außerhalb der Plattform sind gesperrt
 - neu erzeugte, straßenfreie HD-Kartenbasen mit 3344 × 1882 Pixeln und Mipmaps für eine schärfere Windows-Darstellung
 - sechs Türme: Kinetik, Laser, Rakete, Plasma, EMP-Puls und Railgun
- drei Gegnerklassen mit unterschiedlichen Werten
+- neun Gegnerklassen mit Luft- und Bodeneinheiten: Jäger, Fregatte, Kreuzer, Abfangjäger, Schildkreuzer, Luft-Belagerer, schneller Boden-Rover, Panzer und schwerer Läufer
+- neue Bodeneinheiten-Grafiken mit leuchtend grünen Warnmarkierungen und Energielichtern
+- Zielprioritäten für Türme: erste, letzte, höchste verbleibende Hülle oder Schildziele zuerst; Laser priorisiert Schilde immer automatisch
+- Luft-/Bodenvorschau wird durch gleich gestaltete grüne Pfeile unterschieden: Luft nach oben, Boden nach unten
+- Schildgegner haben einen blauen, gegen den Uhrzeigersinn abnehmenden Schildring; Lasertreffer bauen zuerst Schildpunkte ab und übertragen Überschuss auf die Hülle
+- sechs Türme mit klar ausgewiesenen Zielen: Boden, Luft oder beide Kategorien; universelle Türme verursachen reduziert Schaden
+- HUD-Vorschau mit kleinen Einheitensymbolen und Stückzahl für aktuelle und nächste Welle
+- Entwickler-Testregler für Gegner-Lebenspunkte (F9 ein-/ausblenden, +/− verändern; Faktor 0,5×–3,0×, im Online-Koop deaktiviert)
 - 15 automatisch skalierende Missionswellen
- drei wählbare Schwierigkeitsgrade: Leicht entspricht dem bisherigen Balancing, Mittel ist der neue Standard und Schwer erhöht Gegnerhülle, Tempo und Anzahl deutlich
+- drei wählbare Schwierigkeitsgrade: Leicht behält die bisherige Kurve; Schwer startet knapper und erhöht ab Missionsmitte Gegnerhülle, Gegnerzahl und fortgeschrittene Gegnertypen stärker
 - höhere Schwierigkeitsgrade beginnen mit knapperen Ressourcen und belohnen einen Kartensieg mit mehr Kernkristallen
 - freiwilliger Endlosmodus nach Welle 15 mit unbegrenzt weiter skalierenden Gegnern
 - das Ende eines Endloslaufs zählt ausdrücklich nicht als gescheiterte Mission
@@ -86,7 +93,7 @@ Der mitgelieferte Logiktest lässt sich bei Bedarf mit `godot --headless --path

 Für reproduzierbare Windows-Builds steht `packaging/windows/build.ps1` bereit. Godot und NSIS werden als Parameter übergeben; das Skript exportiert das Spiel, erstellt den Installer und gibt anschließend Größe und SHA-256-Prüfsumme aus. Die manuellen Freigabeprüfungen stehen in `ALPHA_TEST_CHECKLIST.md`.

-Die fertigen Hinweise für die erste öffentliche Testversion stehen in `RELEASE_NOTES_0.1.0-alpha.md`.
+Die Hinweise zum aktuellen Windows-Testbuild stehen in `RELEASE_NOTES_0.1.0-alpha.10.md`.

 ## Werbung und Datenschutz

@@ -150,7 +157,7 @@ Die Schaltfläche **Bestenliste** im Hauptmenü zeigt die zwölf besten Piloten.
 4. Freischaltmenü für neue Türme und Karten mit den bereits gespeicherten Kernkristallen
 5. Plattformkonten mit einer eigenen plattformübergreifenden Spieler-ID verbinden
 6. Private Raumcodes und die autoritative Koop-Synchronisierung auf echten Android-, iOS- und Windows-Geräten testen
-7. Freundesliste und direkte Einladungen ergänzen
+7. Freundesliste und direkte Einladungen auf zwei echten Clients mit der neuen Server-Runtime prüfen
 8. Store-Käufe erst nach stabiler Offline- und Koop-Kernversion

 ## Godot Agent Tools MCP
@@ -0,0 +1,16 @@
+# Void Bastion 0.1.0-alpha.10
+
+## Neu in dieser Testversion
+
+- In **Einstellungen** kann zwischen Deutsch und Englisch gewechselt werden. Die Auswahl bleibt nach einem Neustart erhalten. Einzelne ältere Status- und Fehlermeldungen sind noch nicht übersetzt.
+- Der Multiplayer-Bereich enthält eine **Freundesliste**. Spieler können ihre eindeutige Kennung kopieren, andere Spieler darüber hinzufügen und Anfragen bestätigen oder zurückziehen.
+- Bestätigte Freunde werden als **online**, **im Spiel** oder **offline** angezeigt. Der Status wird nach einer unterbrochenen Echtzeitverbindung wiederhergestellt.
+- Ersteller eines privaten Raums können bestätigten Freunden eine direkte Raumeinladung senden. Die Einladung enthält nur einen Raumcode und einen Absendernamen; es gibt keinen Chat und keine frei formulierbaren Nachrichten.
+- Einladungen werden vom Server auf Raumhoheit und gegenseitige Freundschaft geprüft und gegen wiederholtes Senden begrenzt.
+
+## Testhinweise
+
+- Die Freundes- und Einladungsfunktionen benötigen die zu dieser Version passende Nakama-Serverlogik. Beide Spieler sollten Alpha 10 verwenden.
+- Bitte mit zwei Konten Freundschaftsanfrage, Statuswechsel, Einladung und Beitritt testen. Eine Einladung ist flüchtig und wird nicht als Offline-Nachricht gespeichert.
+- Die englischen Texte bitte in Hauptmenü, Shop, Mission und Koop prüfen; noch deutsche Meldungen können gemeldet werden.
+- Dies ist weiterhin eine unsignierte Alpha-Testversion. Windows SmartScreen kann vor dem ersten Start warnen.
@@ -0,0 +1,18 @@
+# Void Bastion 0.1.0-alpha.5
+
+Diese Windows-Testversion erweitert die Gegnerflotte und zieht die Balance der schwierigeren Einsätze an.
+
+## Neu
+
+- drei zusätzliche Gegnertypen: Abfangjäger, Schildträger und Belagerungszerstörer
+- neue Flugzeug- und Schiffsgrafiken für die zusätzlichen Gegnertypen
+
+## Verbessert
+
+- höhere Gegnerzahl und stärkere Hüllenwerte in mittleren und späten Wellen auf den Schwierigkeitsgraden Mittel und Schwer
+- fortgeschrittene Gegner erscheinen auf höheren Schwierigkeitsgraden früher und häufiger
+- Wellen nach dem Missionssieg skalieren im Endlosmodus weiter
+
+## Hinweis
+
+Void Bastion befindet sich weiterhin in einer frühen Alpha-Phase. Unter Windows erscheint keine Werbung. Updates werden im Spiel angekündigt, aber niemals ungefragt installiert. Ruckmeldungen und Fehlerberichte bitte an support@gergames.de senden.
@@ -0,0 +1,18 @@
+# Void Bastion 0.1.0-alpha.6
+
+## Luft- und Bodeneinheiten
+
+- Drei neue Bodengegner: schneller Rover, schwerer Panzer und Belagerungsläufer.
+- Alle drei Bodeneinheiten haben jetzt deutlich sichtbare leuchtend grüne Akzente.
+- Türme zeigen ihre Zielklasse an und greifen nur passende Einheiten an. Laser, Plasma und Railgun können beide Klassen treffen, verursachen dabei aber weniger Schaden.
+- Für ausgewählte Türme lässt sich die Zielpriorität zwischen erster, letzter, höchster verbleibender Hülle und Schildzielen wechseln. Lasertürme priorisieren Schildgegner immer automatisch, sowohl lokal als auch im Online-Koop.
+- Schildgegner haben jetzt ein eigenes Schild-Lebenskonto. Lasertreffer bauen es zuerst ab; überschüssiger Schaden geht danach auf die Hülle. Das Schild wird als blauer Ring dargestellt, dessen verbleibender Anteil gegen den Uhrzeigersinn schrumpft.
+- In der Wellenvorschau zeigen gleich gestaltete grüne Richtungspfeile nach oben für Luft und nach unten für Boden.
+- Die Vorschau nennt jetzt zusätzlich die Gesamtzahl aller Schiffe der Welle und zeigt die Stückzahl pro sichtbarem Gegnertyp gut lesbar neben dessen Miniatur.
+- Gegnerwellen werden vorab deterministisch geplant. Die HUD-Leiste zeigt kompakt die aktuelle und nächste Welle mit Kategorie, Einheitensymbol und Anzahl.
+- Im lokalen Testmodus lässt sich die Gegner-Lebenspunkte-Stärke mit **F9** einblenden und über **− / +** zwischen **0,5× und 3,0×** einstellen. Der Faktor gilt auch für bereits aktive lokale Gegner und ist im Online-Koop gesperrt.
+- Dasselbe Testfeld kann mit **−25 / +25** den lokalen Kernkristallstand für Shop- und Freischalttests verändern; der Teststand wird gespeichert und fällt nie unter null.
+
+## Hinweis
+
+Diese Änderung ist ein Entwicklungsstand und wurde noch nicht als öffentliches Setup veröffentlicht. Online-Koop-Wellen verwenden dieselben Einheitentypen, Klassenregeln und Wellenplanung; der lokale Testmultiplikator verändert keine Online-Partie.
@@ -0,0 +1,16 @@
+# Void Bastion 0.1.0-alpha.7
+
+## Neue Einheiten und Türme
+
+- Drei Bodengegner – Rover, Panzer und Belagerungsläufer – sind mit grünen Leuchtelementen besser von Lufteinheiten unterscheidbar.
+- Die Turmauswahl ist nach Zielklasse sortiert: zuerst reine Luftabwehr, dann Bodenabwehr, danach Mehrzwecktürme. Aktuell gibt es noch keinen reinen Luftabwehrturm.
+- Die Felder der Turmauswahl sind leicht eingefärbt: Rot für Luft, Grün für Boden und Blau-Cyan für Luft/Boden.
+- Der Railgun-Strahl ist lila und durchschlägt alle Gegner auf seiner Schusslinie, auch Ziele hinter dem zuerst anvisierten Gegner. Schilde werden weiterhin durchschlagen.
+- Der EMP-Puls trifft Luft- und Bodeneinheiten im Explosionsradius mit je 20 Schaden.
+- Schildgegner, Zielprioritäten und die Wellenübersicht zeigen jetzt die Luft-/Bodenklassen und Stückzahlen.
+- Im lokalen Entwicklermodus lassen sich Gegnerstärke und Kernkristalle zum Testen anpassen.
+
+## Testhinweise
+
+- Spiel- und Servertests wurden im Headless-Modus ausgeführt.
+- Windows-Setup und Online-Koop müssen vor einer öffentlichen Freigabe zusätzlich praktisch auf dem Zielsystem geprüft werden.
@@ -0,0 +1,12 @@
+# Void Bastion 0.1.0-alpha.8
+
+## Fehlerbehebung für Windows-Updates
+
+- Der Windows-Export wurde frisch erzeugt und anschließend vor dem Verpacken headless gestartet, um beschädigte eingebettete Projektdaten zu erkennen.
+- Das Buildskript bricht künftig ab, wenn `project.binary` nicht geladen werden kann; ein fehlerhafter NSIS-Installer wird so nicht mehr gebaut.
+- Enthält die Spiel- und Balance-Änderungen aus Alpha 7.
+
+## Testhinweise
+
+- Der exportierte Windows-Build wurde headless gestartet und konnte die eingebetteten Godot-Projektdaten laden.
+- Smoke-Test und Nakama-Simulation wurden ausgeführt.
@@ -0,0 +1,15 @@
+# Void Bastion 0.1.0-alpha.9
+
+## Online-Koop-Test
+
+- Partneranzeige und Partner-Umschalter sind in der oberen Leiste neu angeordnet; die Partnerenergie wird rechts angezeigt.
+- ESC öffnet auch online das Pausenmenü. Die lokale Partie pausiert; online läuft das gemeinsame Spiel während des Menüs weiter.
+- Der Server sendet Spielzustände jetzt mit 10 statt 5 Aktualisierungen pro Sekunde.
+- Schüsse werden im Serverzustand mitgesendet und auf beiden Clients als passende Projektil- oder Strahleffekte dargestellt.
+- Der Flakturm ist als Luftabwehr in der Serverlogik ergänzt und greift keine Bodeneinheiten an.
+- Serverseitige Freischaltcodes sind für Türme, Karten oder beides enthalten; Einlösen ist angemeldeten Spielern vorbehalten und gegen Rateversuche geschützt.
+
+## Testhinweise
+
+- Godot-Headless-Start und die Nakama-Runtime-Simulation müssen vor Veröffentlichung erfolgreich durchlaufen.
+- Der Online-Test benötigt zusätzlich das passende Nakama-Runtime-Bundle auf dem Server.
@@ -0,0 +1 @@
+4.7.2.stable
@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://bnkdjurvbhyxn"
+path="res://.godot/imported/enemy_ground_rover.png-78b1629e1d50e53aefbd44cf187db541.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/enemy_ground_rover.png"
+dest_files=["res://.godot/imported/enemy_ground_rover.png-78b1629e1d50e53aefbd44cf187db541.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1
@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://dw874rt1gjjq4"
+path="res://.godot/imported/enemy_ground_tank.png-a69deadc2b1612bb3304c457aae904a7.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/enemy_ground_tank.png"
+dest_files=["res://.godot/imported/enemy_ground_tank.png-a69deadc2b1612bb3304c457aae904a7.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1
@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://cpa443bn3712c"
+path="res://.godot/imported/enemy_ground_walker.png-97fb77912dc8b92904da3219a9ad1771.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/enemy_ground_walker.png"
+dest_files=["res://.godot/imported/enemy_ground_walker.png-97fb77912dc8b92904da3219a9ad1771.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1
@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://dq8ng1q3sipdj"
+path="res://.godot/imported/enemy_interceptor.png-25fe15248366da5309a562c7fda1695b.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/enemy_interceptor.png"
+dest_files=["res://.godot/imported/enemy_interceptor.png-25fe15248366da5309a562c7fda1695b.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1
@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://d0c55da7vg2x8"
+path="res://.godot/imported/enemy_shield_carrier.png-5797af82d40d1f3dfd002a92a5efe490.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/enemy_shield_carrier.png"
+dest_files=["res://.godot/imported/enemy_shield_carrier.png-5797af82d40d1f3dfd002a92a5efe490.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1
@@ -0,0 +1,40 @@
+[remap]
+
+importer="texture"
+type="CompressedTexture2D"
+uid="uid://7vnc3kiipsqj"
+path="res://.godot/imported/enemy_siege_destroyer.png-b87dfe2af9a477c9a1f1ee85d55de962.ctex"
+metadata={
+"vram_texture": false
+}
+
+[deps]
+
+source_file="res://assets/enemy_siege_destroyer.png"
+dest_files=["res://.godot/imported/enemy_siege_destroyer.png-b87dfe2af9a477c9a1f1ee85d55de962.ctex"]
+
+[params]
+
+compress/mode=0
+compress/high_quality=false
+compress/lossy_quality=0.7
+compress/uastc_level=0
+compress/rdo_quality_loss=0.0
+compress/hdr_compression=1
+compress/normal_map=0
+compress/channel_pack=0
+mipmaps/generate=false
+mipmaps/limit=-1
+roughness/mode=0
+roughness/src_normal=""
+process/channel_remap/red=0
+process/channel_remap/green=1
+process/channel_remap/blue=2
+process/channel_remap/alpha=3
+process/fix_alpha_border=true
+process/premult_alpha=false
+process/normal_map_invert_y=false
+process/hdr_as_srgb=false
+process/hdr_clamp_exposure=false
+process/size_limit=0
+detect_3d/compress_to=1
@@ -24,8 +24,8 @@ application/modify_resources=true
 application/icon="res://assets/app_icon.png"
 application/console_wrapper_icon=""
 application/icon_interpolation=4
-application/file_version="0.1.0.4"
-application/product_version="0.1.0.4"
+application/file_version="0.1.0.10"
+application/product_version="0.1.0.10"
 application/company_name="GerGames"
 application/product_name="Void Bastion"
 application/file_description="Void Bastion – Alpha-Testversion"
@@ -62,6 +62,7 @@ architectures/x86=false
 architectures/x86_64=false
 package/name="Void Bastion"
 package/unique_name="de.gergames.voidbastion"
+version/code=2
 package/signed=true
 screen/immersive_mode=true
 permissions/internet=true
@@ -118,6 +119,7 @@ architectures/x86=false
 architectures/x86_64=true
 package/name="Void Bastion"
 package/unique_name="de.gergames.voidbastion"
+version/code=2
 package/signed=true
 screen/immersive_mode=true
 permissions/internet=true
@@ -10,6 +10,8 @@ signal match_found(match_data)
 signal match_snapshot_received(snapshot: Dictionary)
 signal match_event_received(event: Dictionary)
 signal private_room_created(room_code: String)
+signal friends_changed()
+signal match_invite_received(invite: Dictionary)

 const SERVER_KEY := "voidbastion-public-v1"
 const PRODUCTION_HOST := "api.void-bastion.gergames.de"
@@ -22,6 +24,7 @@ const OP_UPGRADE := 11
 const OP_SELL := 12
 const OP_START_WAVE := 13
 const OP_READY := 14
+const MAX_PENDING_SNAPSHOTS := 5

 var client: NakamaClient
 var session: NakamaSession
@@ -37,6 +40,18 @@ var intentional_disconnect := false
 var reconnect_in_progress := false
 var account_manager: AccountManager
 var auto_connect_enabled := true
+var snapshot_previous_ms := 0
+var snapshot_report_ms := 0
+var snapshot_count := 0
+var snapshot_gap_max_ms := 0
+var snapshot_bytes_max := 0
+var snapshot_parse_max_us := 0
+var snapshot_large_gap_count := 0
+var snapshot_coalesced_count := 0
+var pending_snapshot_payloads: Array[String] = []
+var friends: Array[Dictionary] = []
+var friend_statuses: Dictionary = {}
+var presence_status := ""


 func _ready() -> void:
@@ -46,6 +61,35 @@ func _ready() -> void:
 	call_deferred("connect_and_authenticate")


+func _process(_delta: float) -> void:
+	_flush_pending_snapshots()
+
+
+func _flush_pending_snapshots() -> void:
+	if pending_snapshot_payloads.is_empty():
+		return
+	var payloads := pending_snapshot_payloads.duplicate()
+	pending_snapshot_payloads.clear()
+	var latest: Dictionary = {}
+	var recent_shots: Array = []
+	for payload in payloads:
+		var parse_start_us := Time.get_ticks_usec()
+		var parsed = JSON.parse_string(payload)
+		snapshot_parse_max_us = maxi(snapshot_parse_max_us, Time.get_ticks_usec() - parse_start_us)
+		if not parsed is Dictionary:
+			continue
+		latest = parsed
+		var shots = parsed.get("shots", [])
+		if shots is Array:
+			recent_shots.append_array(shots)
+	if latest.is_empty():
+		return
+	if payloads.size() > 1:
+		latest["shots"] = recent_shots
+		snapshot_coalesced_count += payloads.size() - 1
+	match_snapshot_received.emit(latest)
+
+
 func _is_headless_or_editor() -> bool:
 	return DisplayServer.get_name() == "headless" or Engine.is_editor_hint()

@@ -96,6 +140,8 @@ func _after_authentication() -> void:
 	else:
 		intentional_disconnect = false
 		_set_connection_state("online")
+		var parent_game = get_parent()
+		await set_presence_status("playing" if parent_game != null and parent_game.game_mode in ["playing", "paused", "victory", "game_over", "endless_offer", "endless_result"] else "menu")
 	authenticated.emit(session.user_id, session.username)
 	await flush_pending_scores()

@@ -113,16 +159,22 @@ func _record_activity() -> void:
 func _bind_socket_signals() -> void:
 	socket.received_matchmaker_matched.connect(_on_matchmaker_matched)
 	socket.received_match_state.connect(_on_match_state)
+	socket.received_status_presence.connect(_on_status_presence)
+	socket.received_notification.connect(_on_notification)
 	socket.closed.connect(_on_socket_closed)


 func disconnect_from_server() -> void:
 	intentional_disconnect = true
+	pending_snapshot_payloads.clear()
 	if socket:
 		socket.close()
 	socket = null
 	session = null
 	current_match = null
+	friends.clear()
+	friend_statuses.clear()
+	presence_status = ""
 	matchmaker_ticket = ""
 	private_room_code = ""
 	lobby_ready = false
@@ -190,6 +242,124 @@ func delete_online_account() -> Dictionary:
 	return {"accepted": true}


+func redeem_unlock_code(code: String) -> Dictionary:
+	if not is_authenticated():
+		return {"accepted": false, "error": "offline"}
+	var result = await client.rpc_async(session, "redeem_unlock_code", JSON.stringify({"code": code}))
+	var parsed := _parse_rpc_result(result)
+	if parsed.is_empty():
+		return {"accepted": false, "error": "invalid"}
+	return parsed
+
+
+func get_promo_unlocks() -> Dictionary:
+	if not is_authenticated():
+		return {}
+	var result = await client.rpc_async(session, "get_promo_unlocks", "{}")
+	var parsed := _parse_rpc_result(result)
+	return parsed if bool(parsed.get("accepted", false)) else {}
+
+
+func set_presence_status(value: String) -> void:
+	if not is_online() or value == presence_status:
+		return
+	var safe_value := "playing" if value == "playing" else "menu"
+	var result = await socket.update_status_async(safe_value)
+	if result != null and not result.is_exception():
+		presence_status = safe_value
+
+
+func refresh_friends() -> bool:
+	if not is_authenticated():
+		return false
+	var result = await client.list_friends_async(session, null, 100)
+	if result == null or result.is_exception():
+		return false
+	var rows: Array[Dictionary] = []
+	var follow_ids := PackedStringArray()
+	for item in result.friends:
+		if item.user == null:
+			continue
+		var user_id: String = item.user.id
+		var state: int = item.state
+		rows.append({"id": user_id, "username": item.user.username,
+			"name": item.user.display_name if not item.user.display_name.is_empty() else item.user.username,
+			"state": state, "online": item.user.online})
+		if state == 0:
+			follow_ids.append(user_id)
+	friends = rows
+	friend_statuses.clear()
+	if is_online() and not follow_ids.is_empty():
+		var statuses = await socket.follow_users_async(follow_ids, PackedStringArray())
+		if statuses != null and not statuses.is_exception():
+			for presence in statuses.presences:
+				friend_statuses[presence.user_id] = presence.status
+	friends_changed.emit()
+	return true
+
+
+func add_friend_by_username(username: String) -> bool:
+	var normalized := username.strip_edges()
+	if not is_authenticated() or normalized.is_empty() or normalized == session.username:
+		return false
+	var result = await client.add_friends_async(session, null, PackedStringArray([normalized]))
+	if result == null or result.is_exception():
+		return false
+	await refresh_friends()
+	return true
+
+
+func accept_friend(user_id: String) -> bool:
+	if not is_authenticated() or user_id.is_empty():
+		return false
+	var result = await client.add_friends_async(session, PackedStringArray([user_id]))
+	if result == null or result.is_exception():
+		return false
+	await refresh_friends()
+	return true
+
+
+func remove_friend(user_id: String) -> bool:
+	if not is_authenticated() or user_id.is_empty():
+		return false
+	var result = await client.delete_friends_async(session, PackedStringArray([user_id]))
+	if result == null or result.is_exception():
+		return false
+	friend_statuses.erase(user_id)
+	await refresh_friends()
+	return true
+
+
+func invite_friend(user_id: String, room_code: String) -> bool:
+	if not is_authenticated() or user_id.is_empty() or room_code.length() != 6:
+		return false
+	var result = await client.rpc_async(session, "invite_friend", JSON.stringify({"friend_id": user_id, "room_code": room_code}))
+	return bool(_parse_rpc_result(result).get("accepted", false))
+
+
+func _on_status_presence(event) -> void:
+	for presence in event.joins:
+		friend_statuses[presence.user_id] = presence.status
+	for presence in event.leaves:
+		friend_statuses.erase(presence.user_id)
+	friends_changed.emit()
+
+
+func _on_notification(notification) -> void:
+	if notification.code in [-2, -3]:
+		refresh_friends()
+		return
+	if notification.code != 101:
+		return
+	var content = JSON.parse_string(notification.content)
+	if not content is Dictionary:
+		return
+	var code := String(content.get("room_code", ""))
+	if code.length() != 6:
+		return
+	match_invite_received.emit({"room_code": code, "from": String(content.get("from", "Mitspieler"))})
+
+
 func load_leaderboard(map_index: int, difficulty_index: int, endless: bool, limit := 20) -> Array:
 	if not is_authenticated():
 		return []
@@ -245,6 +415,7 @@ func begin_matchmaking(mode := "quick", difficulty := 1) -> bool:

 func cancel_matchmaking() -> void:
 	intentional_disconnect = true
+	pending_snapshot_payloads.clear()
 	if socket and not matchmaker_ticket.is_empty():
 		await socket.remove_matchmaker_async(matchmaker_ticket)
 	matchmaker_ticket = ""
@@ -257,6 +428,7 @@ func cancel_matchmaking() -> void:

 func create_private_room(difficulty := 1) -> bool:
 	intentional_disconnect = false
+	pending_snapshot_payloads.clear()
 	if not is_online() or socket == null:
 		matchmaking_state_changed.emit("offline")
 		return false
@@ -284,6 +456,7 @@ func create_private_room(difficulty := 1) -> bool:

 func join_private_room(room_code: String) -> bool:
 	intentional_disconnect = false
+	pending_snapshot_payloads.clear()
 	if not is_online() or socket == null:
 		matchmaking_state_changed.emit("offline")
 		return false
@@ -310,6 +483,7 @@ func join_private_room(room_code: String) -> bool:

 func _on_matchmaker_matched(matched) -> void:
 	intentional_disconnect = false
+	pending_snapshot_payloads.clear()
 	matchmaker_ticket = ""
 	current_match = await socket.join_matched_async(matched)
 	if current_match == null or current_match.is_exception():
@@ -351,6 +525,7 @@ func request_wave_start() -> bool:


 func leave_current_match() -> void:
+	pending_snapshot_payloads.clear()
 	if socket and current_match != null:
 		await socket.leave_match_async(current_match.match_id)
 	current_match = null
@@ -361,16 +536,44 @@ func leave_current_match() -> void:
 func _on_match_state(data) -> void:
 	if current_match == null or data.match_id != current_match.match_id:
 		return
-	var parsed = JSON.parse_string(data.data)
-	if not parsed is Dictionary:
-		return
 	if data.op_code == OP_SNAPSHOT:
-		match_snapshot_received.emit(parsed)
+		var now_ms := Time.get_ticks_msec()
+		if snapshot_previous_ms > 0:
+			var gap_ms := now_ms - snapshot_previous_ms
+			snapshot_gap_max_ms = maxi(snapshot_gap_max_ms, gap_ms)
+			if gap_ms > 500:
+				snapshot_large_gap_count += 1
+		snapshot_previous_ms = now_ms
+		snapshot_count += 1
+		snapshot_bytes_max = maxi(snapshot_bytes_max, String(data.data).to_utf8_buffer().size())
+		pending_snapshot_payloads.append(String(data.data))
+		if pending_snapshot_payloads.size() > MAX_PENDING_SNAPSHOTS:
+			pending_snapshot_payloads.pop_front()
+			snapshot_coalesced_count += 1
+		if snapshot_report_ms == 0:
+			snapshot_report_ms = now_ms
+		elif now_ms - snapshot_report_ms >= 10000:
+			print("ONLINE DIAG snapshots=%d coalesced=%d max_gap_ms=%d gaps_over_500ms=%d max_bytes=%d max_parse_us=%d" % [snapshot_count, snapshot_coalesced_count, snapshot_gap_max_ms, snapshot_large_gap_count, snapshot_bytes_max, snapshot_parse_max_us])
+			snapshot_report_ms = now_ms
+			snapshot_count = 0
+			snapshot_coalesced_count = 0
+			snapshot_gap_max_ms = 0
+			snapshot_large_gap_count = 0
+			snapshot_bytes_max = 0
+			snapshot_parse_max_us = 0
 	elif data.op_code == OP_EVENT:
+		var parsed = JSON.parse_string(data.data)
+		if parsed is Dictionary:
 			match_event_received.emit(parsed)


 func _on_socket_closed() -> void:
+	print("ONLINE DIAG websocket_closed reconnect=%s" % str(not intentional_disconnect and current_match != null))
+	pending_snapshot_payloads.clear()
+	presence_status = ""
+	friend_statuses.clear()
+	friends_changed.emit()
+	snapshot_previous_ms = 0
 	var reconnect_match_id := ""
 	if not intentional_disconnect and current_match != null:
 		reconnect_match_id = String(current_match.match_id)
@@ -381,6 +584,28 @@ func _on_socket_closed() -> void:
 		reconnect_in_progress = true
 		matchmaking_state_changed.emit("reconnecting")
 		_recover_match.call_deferred(reconnect_match_id)
+	elif not intentional_disconnect and reconnect_match_id.is_empty() and not reconnect_in_progress and is_authenticated():
+		reconnect_in_progress = true
+		_recover_presence.call_deferred()
+
+
+func _recover_presence() -> void:
+	for attempt in 5:
+		await get_tree().create_timer(1.5 + attempt).timeout
+		if intentional_disconnect or not is_authenticated():
+			break
+		socket = Nakama.create_socket_from(client)
+		_bind_socket_signals()
+		var connected = await socket.connect_async(session, true, 5)
+		if connected == null or connected.is_exception():
+			continue
+		reconnect_in_progress = false
+		_set_connection_state("online")
+		var parent_game = get_parent()
+		await set_presence_status("playing" if parent_game != null and parent_game.game_mode in ["playing", "paused", "victory", "game_over", "endless_offer", "endless_result"] else "menu")
+		await refresh_friends()
+		return
+	reconnect_in_progress = false


 func _recover_match(match_id: String) -> void:
@@ -395,13 +620,17 @@ func _recover_match(match_id: String) -> void:
 			continue
 		var rejoined = await socket.join_match_async(match_id)
 		if rejoined != null and not rejoined.is_exception():
+			print("ONLINE DIAG websocket_reconnected attempt=%d" % (attempt + 1))
 			current_match = rejoined
 			intentional_disconnect = false
 			reconnect_in_progress = false
 			_set_connection_state("online")
+			var parent_game = get_parent()
+			await set_presence_status("playing" if parent_game != null and parent_game.game_mode in ["playing", "paused", "victory", "game_over"] else "menu")
 			matchmaking_state_changed.emit("reconnected")
 			return
 	reconnect_in_progress = false
+	print("ONLINE DIAG websocket_reconnect_failed")
 	matchmaking_state_changed.emit("connection_lost")


@@ -2,11 +2,31 @@ param(
    [Parameter(Mandatory = $true)]
    [string]$GodotExe,

-    [Parameter(Mandatory = $true)]
    [string]$MakeNsisExe
 )

 $ErrorActionPreference = "Stop"
+$nsisCandidates = @()
+if (-not [string]::IsNullOrWhiteSpace($MakeNsisExe)) {
+    $nsisCandidates += $MakeNsisExe
+} else {
+    $pathNsis = Get-Command "makensis.exe" -ErrorAction SilentlyContinue
+    if ($pathNsis) {
+        $nsisCandidates += $pathNsis.Source
+    }
+    $nsisCandidates += @(
+        (Join-Path $env:LOCALAPPDATA "Programs\NSIS-3.13\Bin\makensis.exe"),
+        (Join-Path $env:LOCALAPPDATA "Programs\NSIS-3.13\makensis.exe"),
+        "C:\Program Files (x86)\NSIS\makensis.exe",
+        "C:\Program Files\NSIS\makensis.exe"
+    )
+    $MakeNsisExe = $nsisCandidates | Where-Object { Test-Path -LiteralPath $_ -PathType Leaf } | Select-Object -First 1
+}
+
+if ([string]::IsNullOrWhiteSpace($MakeNsisExe)) {
+    throw "NSIS wurde nicht gefunden. Installiere NSIS oder übergib -MakeNsisExe mit dem Pfad zu makensis.exe."
+}
+
 $projectRoot = (Resolve-Path (Join-Path $PSScriptRoot "..\..")).Path
 $gameExe = Join-Path $projectRoot "build\windows\Void-Bastion.exe"
 $installer = Join-Path $projectRoot "dist\Void-Bastion-Setup-x64.exe"
@@ -34,6 +54,15 @@ try {
    if ($LASTEXITCODE -ne 0 -or -not (Test-Path -LiteralPath $gameExe)) {
        throw "Der Godot-Windows-Export ist fehlgeschlagen."
    }
+
+    # Prüft, dass Godot die eingebetteten Projektdaten tatsächlich laden kann,
+    # bevor NSIS daraus einen Installer erstellt. Ein bloß vorhandenes EXE reicht
+    # nicht: ein defektes project.binary würde erst beim Start des Spiels auffallen.
+    $launchOutput = & $gameExe --headless --quit 2>&1 | Out-String
+    $launchExitCode = $LASTEXITCODE
+    if (($null -ne $launchExitCode -and $launchExitCode -ne 0) -or $launchOutput -match "Corrupted header in binary project\.binary|Couldn't load project data|Is the \.pck file missing") {
+        throw "Der exportierte Windows-Build kann seine Projektdaten nicht laden. NSIS-Installer wurde nicht erstellt. Ausgabe: $launchOutput"
+    }
 }
 finally {
    Set-Content -LiteralPath $projectFile -Value $projectConfiguration -NoNewline
@@ -6,7 +6,7 @@ RequestExecutionLevel user
 !include "LogicLib.nsh"

 !define PRODUCT_NAME "Void Bastion"
-!define PRODUCT_VERSION "0.1.0-alpha.4"
+!define PRODUCT_VERSION "0.1.0-alpha.10"
 !define PRODUCT_PUBLISHER "GerGames"
 !define PRODUCT_WEBSITE "https://void-bastion.gergames.de/"
 !define PRODUCT_EXE "Void-Bastion.exe"
@@ -21,7 +21,7 @@ BrandingText "GerGames"
 ShowInstDetails show
 ShowUninstDetails show

-VIProductVersion "0.1.0.4"
+VIProductVersion "0.1.0.10"
 VIAddVersionKey /LANG=1031 "ProductName" "${PRODUCT_NAME}"
 VIAddVersionKey /LANG=1031 "CompanyName" "${PRODUCT_PUBLISHER}"
 VIAddVersionKey /LANG=1031 "FileDescription" "${PRODUCT_NAME} Setup"
@@ -15,7 +15,7 @@ compatibility/default_parent_skeleton_in_mesh_instance_3d=true
 [application]

 config/name="Void Bastion"
-config/version="0.1.0-alpha.4"
+config/version="0.1.0-alpha.10"
 run/main_scene="res://main.tscn"
 config/features=PackedStringArray("4.7")
 config/icon="res://assets/app_icon.png"
@@ -43,5 +43,4 @@ enabled=PackedStringArray("res://addons/agent_tools/plugin.cfg", "res://addons/A
 [rendering]

 renderer/rendering_method="gl_compatibility"
-renderer/rendering_method.mobile="gl_compatibility"
 textures/vram_compression/import_etc2_astc=true
@@ -28,9 +28,14 @@ Für eine öffentliche Testversion wird Port 7350 später über Nginx Proxy Mana

 Der Stack verwendet fest versioniertes Nakama 3.37.0 und PostgreSQL 16 Alpine. Vor einem Versionswechsel werden Datenbank und Nakama-Appdata gesichert und die offiziellen Migrationshinweise geprüft.

+## Freunde und Einladungen
+
+Freundschaftsanfragen, bestätigte Freundschaften und Online-Präsenz verwenden die eingebauten Nakama-Funktionen. Die app-eigene RPC `invite_friend` nimmt ausschließlich die Freundes-ID und einen sechsstelligen privaten Raumcode entgegen. Sie prüft, dass der Absender den Raum erstellt hat und eine gegenseitige Freundschaft besteht. Je Empfänger gilt ein Mindestabstand von 15 Sekunden. Die Benachrichtigung ist nicht persistent und enthält nur Absendername und Raumcode; ein Chat oder frei eingebbarer Einladungstext existiert nicht. Die Funktion muss zusammen mit dem aktualisierten Godot-Client ausgerollt werden.
+
 ## Private Statistik-RPCs

 - `record_activity`: nur für angemeldete Spieler; aktualisiert die pseudonyme Aktivität sowie aggregierte Plattform- und Versionswerte.
 - `private_stats`: nur als Server-zu-Server-Aufruf mit `NAKAMA_HTTP_KEY`; liefert die zusammengefassten Werte für die interne Homepage.
+- `create_unlock_code`, `list_unlock_codes` und `delete_unlock_code`: nur Server-zu-Server mit `NAKAMA_HTTP_KEY`; verwalten private Freischaltcodes inklusive Einlösungsstatus und optionaler Admin-Bemerkung. Löschen ist nur bei null Einlösungen möglich; eine versionsgebundene Löschung schützt vor einer gleichzeitigen Einlösung.

-Die echte Webhosting-Konfiguration mit dem HTTP-Schlüssel darf nicht in Git abgelegt werden.
+Der Code-Lookup verwendet einen SHA-256-Schlüssel. Für die private Admin-Übersicht wird der Klartextcode zusätzlich in einem Nakama-Speicherobjekt mit `permissionRead:0` und `permissionWrite:0` gehalten; Spielclients können dieses Objekt nicht lesen. Bemerkungen sind auf 160 Zeichen beschränkt. Die echte Webhosting-Konfiguration mit dem HTTP-Schlüssel darf nicht in Git abgelegt werden.
@@ -1,4 +1,4 @@
-var GAME_VERSION = "0.23";
+var GAME_VERSION = "0.25";
 var MAP_COUNT = 7;
 var DIFFICULTY_COUNT = 3;
 var VALID_MODES = ["mission", "endless", "coop_ai", "coop_online"];
@@ -8,23 +8,38 @@ var ACTIVITY_COLLECTION = "player_activity";
 var ACTIVITY_KEY = "summary";
 var STATS_COLLECTION = "internal_stats";
 var STATS_KEY = "global";
+var PROMO_CODE_COLLECTION = "unlock_codes";
+var PROMO_UNLOCK_COLLECTION = "player_unlocks";
+var PROMO_UNLOCK_KEY = "website_codes";
+var PROMO_ATTEMPT_COLLECTION = "unlock_attempts";
 var SYSTEM_USER_ID = "00000000-0000-0000-0000-000000000000";
 var OP_SNAPSHOT = 1, OP_EVENT = 2, OP_BUILD = 10, OP_UPGRADE = 11, OP_SELL = 12, OP_START_WAVE = 13, OP_READY = 14;
-var TICK_RATE = 10, SNAPSHOT_TICKS = 2, GRID = 80, WORLD_WIDTH = 2960, MIRROR_X = 1480;
-var REACTOR_X = 1480, REACTOR_Y = 440, REACTOR_RADIUS = 112, PLAYFIELD_TOP = 92, PLAYFIELD_BOTTOM = 758;
+var TICK_RATE = 10, SNAPSHOT_TICKS = 1, GRID = 80, WORLD_WIDTH = 2960, MIRROR_X = 1480;
+var REACTOR_X = 1480, REACTOR_Y = 440, REACTOR_RADIUS = 112, PLAYFIELD_TOP = 84, PLAYFIELD_BOTTOM = 758;
 var LEFT_PATH = [[-40,120],[1160,120],[1160,360],[360,360],[360,680],[1400,680],[1400,520],[1480,520]];
 var RIGHT_PATH = [];
 for (var pathIndex = 0; pathIndex < LEFT_PATH.length; pathIndex++) RIGHT_PATH.push([WORLD_WIDTH - LEFT_PATH[pathIndex][0], LEFT_PATH[pathIndex][1]]);
 var PATHS = [LEFT_PATH, RIGHT_PATH];
 var TOWERS = [
-    {cost:120,damage:22,range:190,cooldown:0.55},
-    {cost:180,damage:12,range:165,cooldown:0.18},
-    {cost:250,damage:65,range:260,cooldown:1.40},
-    {cost:230,damage:48,range:240,cooldown:1.05},
-    {cost:210,damage:34,range:215,cooldown:0.92},
-    {cost:300,damage:110,range:330,cooldown:1.85}
+    {cost:120,damage:22,range:190,cooldown:0.55,targetClass:"ground"},
+    {cost:180,damage:12,range:165,cooldown:0.18,targetClass:"both",bothScale:0.82},
+    {cost:250,damage:65,range:260,cooldown:1.40,targetClass:"ground"},
+    {cost:230,damage:34,range:240,cooldown:1.05,targetClass:"both",bothScale:0.72},
+    {cost:210,damage:20,range:215,cooldown:0.92,targetClass:"both",bothScale:1},
+    {cost:300,damage:77,range:330,cooldown:1.85,targetClass:"both",bothScale:0.70},
+    {cost:210,damage:20,range:230,cooldown:0.42,targetClass:"air"}
+];
+var ENEMIES = [
+    {category:"air",hp:70,speed:105,reward:18,breachDamage:1},
+    {category:"air",hp:185,speed:72,reward:34,breachDamage:2},
+    {category:"air",hp:520,speed:43,reward:78,breachDamage:3},
+    {category:"air",hp:52,speed:178,reward:22,breachDamage:2},
+    {category:"air",hp:260,speed:58,reward:52,breachDamage:2},
+    {category:"air",hp:740,speed:48,reward:108,breachDamage:4},
+    {category:"ground",hp:88,speed:142,reward:22,breachDamage:1},
+    {category:"ground",hp:390,speed:61,reward:61,breachDamage:3},
+    {category:"ground",hp:980,speed:36,reward:132,breachDamage:5}
 ];
-var ENEMIES = [{hp:70,speed:105,reward:18},{hp:185,speed:72,reward:34},{hp:520,speed:43,reward:78}];
 var DIFFICULTIES = [
    {hp:1,speed:1,count:1,income:1,spawnDelay:1,startCredits:450},
    {hp:1.32,speed:1.07,count:1.24,income:0.94,spawnDelay:0.91,startCredits:430},
@@ -130,6 +145,137 @@ function rpcPrivateStats(ctx, logger, nk, payload) {
    var stats = record && record.value ? record.value : emptyStats(Date.now());
    return JSON.stringify(stats);
 }
+function rpcCreateUnlockCode(ctx, logger, nk, payload) {
+    if (ctx.userId) throw new Error("server-to-server access required");
+    var request;
+    try { request = JSON.parse(payload || "{}"); } catch (error) { throw new Error("invalid JSON payload"); }
+    var reward = String(request.reward || "");
+    if (["all_towers", "all_maps", "all"].indexOf(reward) < 0) throw new Error("invalid unlock reward");
+    var maxUses = clampInteger(request.max_uses === undefined ? 1 : request.max_uses, 1, 50000);
+    var note = String(request.note || "").trim();
+    if (note.length > 160) throw new Error("note exceeds 160 characters");
+    for (var attempt = 0; attempt < 5; attempt++) {
+        var code = nk.uuidv4().replace(/-/g, "").substring(0, 24).toUpperCase();
+        var codeKey = nk.sha256Hash(code);
+        if (readStorageRecord(nk, PROMO_CODE_COLLECTION, codeKey, SYSTEM_USER_ID)) continue;
+        nk.storageWrite([{collection:PROMO_CODE_COLLECTION,key:codeKey,userId:SYSTEM_USER_ID,value:{code:code,reward:reward,note:note,max_uses:maxUses,uses:0,redeemed_users:[],created_at:Date.now()},permissionRead:0,permissionWrite:0,version:"*"}]);
+        return JSON.stringify({accepted:true,code:code,reward:reward,note:note,max_uses:maxUses,uses:0,status:"open"});
+    }
+    throw new Error("could not allocate unique unlock code");
+}
+function rpcListUnlockCodes(ctx, logger, nk, payload) {
+    if (ctx.userId) throw new Error("server-to-server access required");
+    var codes = [], cursor = "", pages = 0;
+    do {
+        var result = nk.storageList(SYSTEM_USER_ID, PROMO_CODE_COLLECTION, 100, cursor);
+        var objects = Array.isArray(result) ? result : (result && Array.isArray(result.objects) ? result.objects : []);
+        for (var i = 0; i < objects.length; i++) {
+            var object = objects[i], value = object && object.value ? object.value : {};
+            var uses = Math.max(0, Math.floor(Number(value.uses || 0)));
+            var maxUses = Math.max(1, Math.floor(Number(value.max_uses || 1)));
+            codes.push({
+                code:String(value.code || ""),
+                code_key:String(object && object.key ? object.key : ""),
+                code_id:String(object && object.key ? object.key : "").slice(-8),
+                reward:String(value.reward || ""),
+                note:String(value.note || ""),
+                uses:uses,
+                max_uses:maxUses,
+                created_at:Number(value.created_at || 0),
+                status:uses >= maxUses ? "redeemed" : (uses > 0 ? "partial" : "open")
+            });
+        }
+        cursor = result && !Array.isArray(result) ? String(result.cursor || "") : "";
+        pages++;
+    } while (cursor && pages < 10);
+    codes.sort(function(a, b) { return b.created_at - a.created_at; });
+    return JSON.stringify({codes:codes,truncated:!!cursor});
+}
+function rpcDeleteUnlockCode(ctx, logger, nk, payload) {
+    if (ctx.userId) throw new Error("server-to-server access required");
+    var request;
+    try { request = JSON.parse(payload || "{}"); } catch (error) { throw new Error("invalid JSON payload"); }
+    var codeKey = String(request.code_key || "").toLowerCase();
+    if (!/^[a-f0-9]{64}$/.test(codeKey)) return JSON.stringify({accepted:false,error:"invalid"});
+    for (var attempt = 0; attempt < 3; attempt++) {
+        var record = readStorageRecord(nk, PROMO_CODE_COLLECTION, codeKey, SYSTEM_USER_ID);
+        if (!record || !record.value) return JSON.stringify({accepted:false,error:"not_found"});
+        var value = record.value;
+        if (Number(value.uses || 0) !== 0 || (Array.isArray(value.redeemed_users) && value.redeemed_users.length > 0)) {
+            return JSON.stringify({accepted:false,error:"already_used"});
+        }
+        if (!record.version) throw new Error("unlock code has no storage version");
+        try {
+            nk.storageDelete([{collection:PROMO_CODE_COLLECTION,key:codeKey,userId:SYSTEM_USER_ID,version:record.version}]);
+            return JSON.stringify({accepted:true});
+        } catch (error) {
+            if (attempt === 2) throw error;
+        }
+    }
+    return JSON.stringify({accepted:false,error:"temporary"});
+}
+function allowPromoAttempt(ctx, nk) {
+    var now = Date.now(), key = "user_" + ctx.userId;
+    for (var attempt = 0; attempt < 3; attempt++) {
+        var record = readStorageRecord(nk, PROMO_ATTEMPT_COLLECTION, key, SYSTEM_USER_ID);
+        var value = record && record.value ? record.value : {window_started:now,count:0};
+        if (now - Number(value.window_started || 0) >= 5 * 60 * 1000) value = {window_started:now,count:0};
+        if (Number(value.count || 0) >= 10) return false;
+        value.count = Number(value.count || 0) + 1;
+        var write = {collection:PROMO_ATTEMPT_COLLECTION,key:key,userId:SYSTEM_USER_ID,value:value,permissionRead:0,permissionWrite:0,version:record && record.version ? record.version : "*"};
+        try { nk.storageWrite([write]); return true; }
+        catch (error) { if (attempt === 2) return false; }
+    }
+    return false;
+}
+function writePromoUnlocks(nk, userId, reward) {
+    for (var attempt = 0; attempt < 3; attempt++) {
+        var record = readStorageRecord(nk, PROMO_UNLOCK_COLLECTION, PROMO_UNLOCK_KEY, userId);
+        var value = record && record.value ? record.value : {all_towers:false,all_maps:false};
+        if (reward === "all_towers" || reward === "all") value.all_towers = true;
+        if (reward === "all_maps" || reward === "all") value.all_maps = true;
+        var write = {collection:PROMO_UNLOCK_COLLECTION,key:PROMO_UNLOCK_KEY,userId:userId,value:value,permissionRead:0,permissionWrite:0,version:record && record.version ? record.version : "*"};
+        try { nk.storageWrite([write]); return value; }
+        catch (error) { if (attempt === 2) throw error; }
+    }
+    throw new Error("could not save player unlocks");
+}
+function rpcRedeemUnlockCode(ctx, logger, nk, payload) {
+    if (!ctx.userId) throw new Error("authentication required");
+    if (!allowPromoAttempt(ctx, nk)) return JSON.stringify({accepted:false,error:"rate_limited"});
+    var request;
+    try { request = JSON.parse(payload || "{}"); } catch (error) { return JSON.stringify({accepted:false,error:"invalid"}); }
+    var code = String(request.code || "").toUpperCase().replace(/[\s-]/g, "");
+    if (!/^[A-F0-9]{24}$/.test(code)) return JSON.stringify({accepted:false,error:"invalid"});
+    var codeKey = nk.sha256Hash(code);
+    for (var attempt = 0; attempt < 4; attempt++) {
+        var record = readStorageRecord(nk, PROMO_CODE_COLLECTION, codeKey, SYSTEM_USER_ID);
+        if (!record || !record.value) return JSON.stringify({accepted:false,error:"invalid"});
+        var value = record.value;
+        var redeemed = Array.isArray(value.redeemed_users) ? value.redeemed_users : [];
+        if (redeemed.indexOf(ctx.userId) >= 0) {
+            var existingUnlocks = writePromoUnlocks(nk, ctx.userId, String(value.reward || ""));
+            return JSON.stringify({accepted:true,already_redeemed:true,reward:value.reward,all_towers:!!existingUnlocks.all_towers,all_maps:!!existingUnlocks.all_maps});
+        }
+        if (Number(value.uses || 0) >= Number(value.max_uses || 1)) return JSON.stringify({accepted:false,error:"exhausted"});
+        value.redeemed_users = redeemed.concat([ctx.userId]);
+        value.uses = Number(value.uses || 0) + 1;
+        try {
+            nk.storageWrite([{collection:PROMO_CODE_COLLECTION,key:codeKey,userId:SYSTEM_USER_ID,value:value,permissionRead:0,permissionWrite:0,version:record.version}]);
+            var unlocks = writePromoUnlocks(nk, ctx.userId, String(value.reward || ""));
+            return JSON.stringify({accepted:true,reward:value.reward,all_towers:!!unlocks.all_towers,all_maps:!!unlocks.all_maps});
+        } catch (error) {
+            if (attempt === 3) throw error;
+        }
+    }
+    return JSON.stringify({accepted:false,error:"temporary"});
+}
+function rpcGetPromoUnlocks(ctx, logger, nk, payload) {
+    if (!ctx.userId) throw new Error("authentication required");
+    var record = readStorageRecord(nk, PROMO_UNLOCK_COLLECTION, PROMO_UNLOCK_KEY, ctx.userId);
+    var value = record && record.value ? record.value : {all_towers:false,all_maps:false};
+    return JSON.stringify({accepted:true,all_towers:!!value.all_towers,all_maps:!!value.all_maps});
+}
 function rpcSubmitRun(ctx, logger, nk, payload) {
    if (!ctx.userId) throw new Error("authentication required");
    var run;
@@ -223,6 +369,40 @@ function rpcJoinPrivateRoom(ctx, logger, nk, payload) {
    return JSON.stringify({found:true,room_code:code,match_id:String(record.value.match_id)});
 }

+function rpcInviteFriend(ctx, logger, nk, payload) {
+    if (!ctx.userId) throw new Error("authentication required");
+    var request;
+    try { request = JSON.parse(payload || "{}"); } catch (error) { return JSON.stringify({accepted:false,error:"invalid_json"}); }
+    var friendId = String(request.friend_id || ""), code = normalizeRoomCode(request.room_code);
+    if (!/^[0-9a-f-]{36}$/i.test(friendId) || code.length !== 6 || friendId === ctx.userId)
+        return JSON.stringify({accepted:false,error:"invalid_invite"});
+    var room = privateRoomRecord(nk, code);
+    if (!room || !room.value || room.value.host_user_id !== ctx.userId)
+        return JSON.stringify({accepted:false,error:"not_room_host"});
+    var mutual = false, cursor = "";
+    for (var page = 0; page < 10 && !mutual; page++) {
+        var result = nk.friendsList(ctx.userId, 100, 0, cursor);
+        var list = Array.isArray(result) ? result : (result && Array.isArray(result.friends) ? result.friends : []);
+        for (var i = 0; i < list.length; i++) {
+            if (list[i].state === 0 && list[i].user && String(list[i].user.userId || list[i].user.id || "") === friendId) { mutual = true; break; }
+        }
+        cursor = result && result.cursor ? result.cursor : "";
+        if (!cursor) break;
+    }
+    if (!mutual) return JSON.stringify({accepted:false,error:"not_mutual_friends"});
+    var rateKey = "invite_" + friendId;
+    var previous = readStorageRecord(nk, "friend_invite_limits", rateKey, ctx.userId);
+    var now = Date.now();
+    if (previous && previous.value && now - Number(previous.value.sent_at || 0) < 15000)
+        return JSON.stringify({accepted:false,error:"invite_cooldown"});
+    var senderName = String(ctx.username || "Pilot");
+    var senders = nk.usersGetId([ctx.userId]);
+    if (senders.length && senders[0].displayName) senderName = String(senders[0].displayName);
+    nk.storageWrite([{collection:"friend_invite_limits",key:rateKey,userId:ctx.userId,value:{sent_at:now},permissionRead:0,permissionWrite:0}]);
+    nk.notificationsSend([{userId:friendId,subject:"Void Bastion Invite",content:{room_code:code,from:senderName.slice(0,32)},code:101,senderId:ctx.userId,persistent:false}]);
+    return JSON.stringify({accepted:true});
+}
+
 function matchmakerMatched(ctx, logger, nk, matches) {
    var difficulty = 1;
    if (matches.length && matches[0].properties && matches[0].properties.difficulty !== undefined) difficulty = Math.max(0,Math.min(2,Math.floor(Number(matches[0].properties.difficulty))));
@@ -231,7 +411,7 @@ function matchmakerMatched(ctx, logger, nk, matches) {
 function initialState(params) {
    var difficulty = Math.max(0,Math.min(2,Math.floor(Number(params.difficulty||1))));
    var credits = DIFFICULTIES[difficulty].startCredits;
-    return {presences:{},slots:{},players:{},ready:{},started:false,pausedForReconnect:false,reconnectDeadlineTick:0,gameOver:false,difficulty:difficulty,mode:String(params.mode||"quick"),roomCode:normalizeRoomCode(params.roomCode),hostUserId:String(params.hostUserId||""),emptyTicks:0,credits:[credits,credits],reactorLives:30,wave:0,waveActive:false,spawnRemaining:0,spawnTimer:0,nextSpawnRoute:0,nextEnemyId:1,nextTowerId:1,towers:[],enemies:[],lastSnapshotTick:0};
+    return {presences:{},slots:{},players:{},ready:{},started:false,pausedForReconnect:false,reconnectDeadlineTick:0,gameOver:false,difficulty:difficulty,mode:String(params.mode||"quick"),roomCode:normalizeRoomCode(params.roomCode),hostUserId:String(params.hostUserId||""),emptyTicks:0,credits:[credits,credits],reactorLives:30,wave:0,waveActive:false,spawnRemaining:0,waveSchedule:[],spawnTimer:0,nextSpawnRoute:0,nextEnemyId:1,nextTowerId:1,towers:[],enemies:[],shots:[],lastSnapshotTick:0,lastLoopStartMs:0};
 }
 function matchLabel(state) { return state.mode === "private" ? state.roomCode : JSON.stringify({game:"void_bastion",mode:state.mode,open:!state.started&&!state.gameOver}); }
 function matchInit(ctx,logger,nk,params) { var state=initialState(params||{}); return {state:state,tickRate:TICK_RATE,label:matchLabel(state)}; }
@@ -247,9 +427,15 @@ function snapshot(state,tick) {
        var id=ids[i],slot=state.slots[id],player=state.players[id]||{};
        lobby[slot]={user_id:id,slot:slot,name:String(player.name||"PILOT"),ready:!!state.ready[id],connected:state.presences[id]!==undefined};
    }
-    return {version:GAME_VERSION,tick:tick,started:state.started,connection_interrupted:state.pausedForReconnect,reconnect_seconds:state.pausedForReconnect?Math.max(0,Math.ceil((state.reconnectDeadlineTick-tick)/TICK_RATE)):0,game_over:state.gameOver,difficulty:state.difficulty,slots:state.slots,players:lobby,credits:state.credits,reactor_lives:state.reactorLives,wave:state.wave,wave_active:state.waveActive,enemies_to_spawn:state.spawnRemaining,towers:state.towers,enemies:state.enemies};
+    var towers=state.towers.map(function(tower) {
+        return {id:tower.id,x:tower.x,y:tower.y,type:tower.type,level:tower.level,owner:tower.owner,angle:Math.round(tower.angle*1000)/1000};
+    });
+    var enemies=state.enemies.map(function(enemy) {
+        return {id:enemy.id,type:enemy.type,x:Math.round(enemy.x*10)/10,y:Math.round(enemy.y*10)/10,path_index:enemy.path_index,route_id:enemy.route_id,hp:Math.round(enemy.hp*10)/10,max_hp:Math.round(enemy.max_hp*10)/10,angle:Math.round(enemy.angle*1000)/1000,boss:enemy.boss,shield:enemy.shield,shield_hp:Math.round(enemy.shield_hp*10)/10,max_shield_hp:Math.round(enemy.max_shield_hp*10)/10};
+    });
+    return {version:GAME_VERSION,tick:tick,started:state.started,connection_interrupted:state.pausedForReconnect,reconnect_seconds:state.pausedForReconnect?Math.max(0,Math.ceil((state.reconnectDeadlineTick-tick)/TICK_RATE)):0,game_over:state.gameOver,difficulty:state.difficulty,slots:state.slots,players:lobby,credits:state.credits,reactor_lives:state.reactorLives,wave:state.wave,wave_active:state.waveActive,enemies_to_spawn:state.spawnRemaining,wave_types_remaining:state.waveSchedule.map(function(entry){return entry.type;}),towers:towers,enemies:enemies,shots:state.shots||[]};
 }
-function broadcastSnapshot(dispatcher,state,tick) { dispatcher.broadcastMessage(OP_SNAPSHOT,JSON.stringify(snapshot(state,tick)),null,null,true); state.lastSnapshotTick=tick; }
+function broadcastSnapshot(dispatcher,state,tick) { dispatcher.broadcastMessage(OP_SNAPSHOT,JSON.stringify(snapshot(state,tick)),null,null,true); state.shots=[]; state.lastSnapshotTick=tick; }
 function broadcastEvent(dispatcher,type,data) { var payload=data||{}; payload.type=type; dispatcher.broadcastMessage(OP_EVENT,JSON.stringify(payload),null,null,true); }
 function matchJoin(ctx,logger,nk,dispatcher,tick,state,presences) {
    var rejoined=false;
@@ -310,16 +496,58 @@ function handleSell(state,slot,payload) {
    var i=ownedTowerIndex(state,slot,Math.floor(Number(payload.tower_id))); if (i<0) return false;
    var tower=state.towers[i]; state.credits[slot]+=Math.floor(TOWERS[tower.type].cost*(0.55+tower.level*0.12)); state.towers.splice(i,1); return true;
 }
+function enemyTypeForWave(wave,roll,difficulty,boss) {
+    if (boss) return wave>=10?8:5;
+    var offset=difficulty===2?2:(difficulty===1?1:0);
+    if (wave>=10&&roll>=0.96) return 8;
+    if (wave>=8&&roll>=0.84&&roll<0.94) return 7;
+    if (wave>=3&&roll>=0.52&&roll<0.64) return 6;
+    if (wave>=10-offset&&roll>=0.94) return 5;
+    if (wave>=7-offset&&roll>=0.80) return 4;
+    if (wave>=4-offset&&roll>=0.65) return 3;
+    if (wave>=7&&roll>=0.45) return 2;
+    if (wave>=3&&roll>=0.28) return 1;
+    return 0;
+}
+function wavePopulation(state,wave) {
+    var scale=1+Math.max(0,wave-3)*0.08;
+    if (state.difficulty===2) scale+=Math.max(0,wave-4)*0.025;
+    return Math.ceil((7+wave*2)*DIFFICULTIES[state.difficulty].count*scale)*2;
+}
+function buildWaveSchedule(state,wave,count) {
+    var schedule=[],bossCount=wave>0&&wave%5===0?2:0;
+    for (var i=0;i<count;i++) {
+        var boss=i>=count-bossCount;
+        var roll=((i+1)*0.61803398875+wave*0.38196601125)%1;
+        schedule.push({type:enemyTypeForWave(wave,roll,state.difficulty,boss),boss:boss});
+    }
+    return schedule;
+}
 function startWave(state) {
    if (state.waveActive||state.gameOver||!state.started) return false;
-    state.wave+=1; state.spawnRemaining=Math.ceil((7+state.wave*2)*DIFFICULTIES[state.difficulty].count)*2; state.spawnTimer=0.1; state.waveActive=true; return true;
+    state.wave+=1; state.waveSchedule=buildWaveSchedule(state,state.wave,wavePopulation(state,state.wave)); state.spawnRemaining=state.waveSchedule.length; state.spawnTimer=0.1; state.waveActive=true; return true;
 }
 function spawnEnemy(state) {
-    var boss=state.wave>0&&state.wave%5===0&&state.spawnRemaining<=2,roll=Math.random();
-    var type=boss?2:(state.wave>=7&&roll>0.82?2:(state.wave>=3&&roll>0.53?1:0));
-    var base=ENEMIES[type],d=DIFFICULTIES[state.difficulty],scale=(1+Math.max(0,state.wave-1)*0.115)*(boss?3.25:1)*d.hp;
+    var entry=state.waveSchedule.length?state.waveSchedule.shift():{type:0,boss:false};
+    var boss=entry.boss,type=entry.type;
+    var base=ENEMIES[type],d=DIFFICULTIES[state.difficulty];
+    var scale=(1+Math.max(0,state.wave-1)*0.20+Math.max(0,state.wave-3)*0.09+((state.difficulty===2)?Math.max(0,state.wave-5)*0.055:0))*(boss?3.25:1)*d.hp;
    var routeId=state.nextSpawnRoute; state.nextSpawnRoute=(state.nextSpawnRoute+1)%2; var route=PATHS[routeId];
-    state.enemies.push({id:state.nextEnemyId++,type:type,x:route[0][0],y:route[0][1],path_index:1,route_id:routeId,hp:base.hp*scale,max_hp:base.hp*scale,speed:base.speed*(1+state.wave*0.012)*(boss?0.82:1)*d.speed,reward:Math.floor((base.reward+state.wave)*(boss?4:1)*d.income),angle:0,boss:boss});
+    var hasShield=type===4||(state.wave>=4&&Math.random()<Math.min(0.42,0.10+state.wave*0.018+state.difficulty*0.06));
+    var maxShieldHp=hasShield?base.hp*scale*0.55:0;
+    state.enemies.push({id:state.nextEnemyId++,type:type,x:route[0][0],y:route[0][1],path_index:1,route_id:routeId,hp:base.hp*scale,max_hp:base.hp*scale,speed:base.speed*(1+state.wave*0.012)*(boss?0.82:1)*d.speed,reward:Math.floor((base.reward+state.wave)*(boss?4:1)*d.income),angle:0,boss:boss,shield:hasShield,shield_hp:maxShieldHp,max_shield_hp:maxShieldHp,shield_resistance:type===4?0.18:0.28});
+}
+function applyDamageToEnemy(enemy,damage,towerType) {
+    var applied=damage;
+    if (enemy.shield) {
+        if (towerType===1) {
+            var shieldDamage=Math.min(enemy.shield_hp,damage);
+            enemy.shield_hp-=shieldDamage;
+            if (enemy.shield_hp<=0) { enemy.shield=false; applied=damage-shieldDamage; }
+            else applied=0;
+        } else if (towerType!==5) applied*=enemy.shield_resistance||0.28;
+    }
+    enemy.hp-=applied;
 }
 function removeEnemy(state,index,owner) { state.credits[owner]+=state.enemies[index].reward; state.enemies.splice(index,1); }
 function updateEnemies(state,delta) {
@@ -328,24 +556,40 @@ function updateEnemies(state,delta) {
        e.angle=Math.atan2(dy,dx);
        if (dist<=Math.max(9,e.speed*delta)) {
            e.x=target[0]; e.y=target[1]; e.path_index+=1;
-            if (e.path_index>=route.length) { state.reactorLives=Math.max(0,state.reactorLives-(1+e.type+(e.boss?4:0))); state.enemies.splice(i,1); if (state.reactorLives<=0) { state.gameOver=true; state.waveActive=false; state.spawnRemaining=0; } }
+            if (e.path_index>=route.length) { state.reactorLives=Math.max(0,state.reactorLives-(ENEMIES[e.type].breachDamage+(e.boss?4:0))); state.enemies.splice(i,1); if (state.reactorLives<=0) { state.gameOver=true; state.waveActive=false; state.spawnRemaining=0; } }
        } else { e.x+=dx/dist*e.speed*delta; e.y+=dy/dist*e.speed*delta; }
    }
 }
 function enemyProgress(e) { return e.path_index*100000-distanceSquared(e.x,e.y,REACTOR_X,REACTOR_Y); }
 function updateTowers(state,delta) {
+    state.shots=state.shots||[];
    for (var i=0;i<state.towers.length;i++) {
-        var t=state.towers[i]; t.cooldown-=delta; var range=towerRange(t),targetIndex=-1,best=-1;
-        for (var j=0;j<state.enemies.length;j++) if (distanceSquared(t.x,t.y,state.enemies[j].x,state.enemies[j].y)<=range*range) { var p=enemyProgress(state.enemies[j]); if (p>best) { best=p; targetIndex=j; } }
+        var t=state.towers[i]; t.cooldown-=delta; var range=towerRange(t),targetIndex=-1,best=-1,bestShield=false;
+        for (var j=0;j<state.enemies.length;j++) {
+            var candidate=state.enemies[j];
+            if ((TOWERS[t.type].targetClass==="both"||TOWERS[t.type].targetClass===ENEMIES[candidate.type].category)&&distanceSquared(t.x,t.y,candidate.x,candidate.y)<=range*range) {
+                var p=enemyProgress(candidate),shieldPriority=t.type===1&&candidate.shield===true;
+                if (targetIndex<0||(shieldPriority&&!bestShield)||(shieldPriority===bestShield&&p>best)) { best=p; bestShield=shieldPriority; targetIndex=j; }
+            }
+        }
        if (targetIndex<0) continue;
        var target=state.enemies[targetIndex]; t.angle=Math.atan2(target.y-t.y,target.x-t.x)+([0,3,5].indexOf(t.type)>=0?Math.PI:0);
        if (t.cooldown>0) continue;
-        var damage=towerDamage(t);
-        if (t.type===2||t.type===3||t.type===4) {
-            var radius=t.type===2?76:(t.type===3?92:118),splash=t.type===2?0.45:(t.type===3?0.62:0.38);
+        state.shots.push({tower_id:t.id,type:t.type,from_x:t.x,from_y:t.y,to_x:target.x,to_y:target.y});
+        var damage=towerDamage(t)*(TOWERS[t.type].targetClass==="both"?TOWERS[t.type].bothScale:1);
+        if (t.type===5) {
+            var aimLength=Math.sqrt(distanceSquared(t.x,t.y,target.x,target.y)),dx=(target.x-t.x)/aimLength,dy=(target.y-t.y)/aimLength,rangeSquared=range*range;
+            for (var railIndex=state.enemies.length-1;railIndex>=0;railIndex--) {
+                var railTarget=state.enemies[railIndex];
+                if (distanceSquared(t.x,t.y,railTarget.x,railTarget.y)>rangeSquared) continue;
+                var offsetX=railTarget.x-t.x,offsetY=railTarget.y-t.y,along=offsetX*dx+offsetY*dy,across=Math.abs(offsetX*dy-offsetY*dx);
+                if (along>=0&&along<=range&&across<=18) { applyDamageToEnemy(railTarget,damage,t.type); if (railTarget.hp<=0) removeEnemy(state,railIndex,t.owner); }
+            }
+        } else if (t.type===2||t.type===3||t.type===4) {
+            var radius=t.type===2?76:(t.type===3?92:118),splash=t.type===2?0.45:(t.type===3?0.62:1);
            var tx=target.x,ty=target.y,targetId=target.id;
-            for (var k=state.enemies.length-1;k>=0;k--) if (distanceSquared(state.enemies[k].x,state.enemies[k].y,tx,ty)<=radius*radius) { state.enemies[k].hp-=state.enemies[k].id===targetId?damage:damage*splash; if (state.enemies[k].hp<=0) removeEnemy(state,k,t.owner); }
-        } else { target.hp-=damage; if (target.hp<=0) removeEnemy(state,targetIndex,t.owner); }
+            for (var k=state.enemies.length-1;k>=0;k--) if ((TOWERS[t.type].targetClass==="both"||TOWERS[t.type].targetClass===ENEMIES[state.enemies[k].type].category)&&distanceSquared(state.enemies[k].x,state.enemies[k].y,tx,ty)<=radius*radius) { applyDamageToEnemy(state.enemies[k],state.enemies[k].id===targetId?damage:damage*splash,t.type); if (state.enemies[k].hp<=0) removeEnemy(state,k,t.owner); }
+        } else { applyDamageToEnemy(target,damage,t.type); if (target.hp<=0) removeEnemy(state,targetIndex,t.owner); }
        t.cooldown=towerCooldown(t);
    }
 }
@@ -378,6 +622,11 @@ function handleCommand(nk,dispatcher,state,message) {
    if (!changed) broadcastEvent(dispatcher,"command_rejected",{op_code:message.opCode,player:slot});
 }
 function matchLoop(ctx,logger,nk,dispatcher,tick,state,messages) {
+    var loopStartMs=Date.now();
+    if (state.lastLoopStartMs && loopStartMs-state.lastLoopStartMs>250 && logger.warn)
+        logger.warn("ONLINE DIAG tick_gap_ms=%d tick=%d",loopStartMs-state.lastLoopStartMs,tick);
+    state.lastLoopStartMs=loopStartMs;
+    state.shots=[];
    if (!Object.keys(state.presences).length) {
        state.emptyTicks += 1;
        if (state.emptyTicks >= TICK_RATE * 60) { deletePrivateRoomRecord(nk,state.roomCode); return null; }
@@ -386,6 +635,8 @@ function matchLoop(ctx,logger,nk,dispatcher,tick,state,messages) {
    if (state.pausedForReconnect&&tick>=state.reconnectDeadlineTick) { state.gameOver=true; state.pausedForReconnect=false; state.waveActive=false; broadcastEvent(dispatcher,"partner_timeout",{}); }
    if (state.started&&!state.pausedForReconnect&&!state.gameOver) { var delta=1/TICK_RATE; updateWave(state,delta,dispatcher); updateEnemies(state,delta); updateTowers(state,delta); }
    if (tick-state.lastSnapshotTick>=SNAPSHOT_TICKS||messages.length) broadcastSnapshot(dispatcher,state,tick);
+    var loopMs=Date.now()-loopStartMs;
+    if (loopMs>70 && logger.warn) logger.warn("ONLINE DIAG loop_ms=%d tick=%d enemies=%d towers=%d",loopMs,tick,state.enemies.length,state.towers.length);
    return {state:state};
 }
 function matchTerminate(ctx,logger,nk,dispatcher,tick,state,graceSeconds) { deletePrivateRoomRecord(nk,state.roomCode); broadcastEvent(dispatcher,"server_shutdown",{grace:graceSeconds}); return {state:state}; }
@@ -396,11 +647,17 @@ function InitModule(ctx,logger,nk,initializer) {
    initializer.registerRpc("server_info",rpcServerInfo);
    initializer.registerRpc("record_activity",rpcRecordActivity);
    initializer.registerRpc("private_stats",rpcPrivateStats);
+    initializer.registerRpc("create_unlock_code",rpcCreateUnlockCode);
+    initializer.registerRpc("list_unlock_codes",rpcListUnlockCodes);
+    initializer.registerRpc("delete_unlock_code",rpcDeleteUnlockCode);
+    initializer.registerRpc("redeem_unlock_code",rpcRedeemUnlockCode);
+    initializer.registerRpc("get_promo_unlocks",rpcGetPromoUnlocks);
    initializer.registerRpc("submit_run",rpcSubmitRun);
    initializer.registerRpc("update_display_name",rpcUpdateDisplayName);
    initializer.registerRpc("delete_account",rpcDeleteAccount);
    initializer.registerRpc("create_private_room",rpcCreatePrivateRoom);
    initializer.registerRpc("join_private_room",rpcJoinPrivateRoom);
+    initializer.registerRpc("invite_friend",rpcInviteFriend);
    initializer.registerMatchmakerMatched(matchmakerMatched);
    initializer.registerMatch(MATCH_MODULE,{matchInit:matchInit,matchJoinAttempt:matchJoinAttempt,matchJoin:matchJoin,matchLeave:matchLeave,matchLoop:matchLoop,matchTerminate:matchTerminate,matchSignal:matchSignal});
    logger.info("Void Bastion online runtime %s loaded",GAME_VERSION);
@@ -2,12 +2,113 @@ const assert = require("assert");
 const fs = require("fs");
 const vm = require("vm");
 const path = require("path");
+const crypto = require("crypto");

 const source = fs.readFileSync(path.join(__dirname, "..", "runtime", "build", "index.js"), "utf8");
 const context = { console, Math, Date, JSON, isFinite };
 vm.createContext(context);
 vm.runInContext(source, context);

+assert.strictEqual(context.ENEMIES.length, 9);
+assert.strictEqual(context.SNAPSHOT_TICKS, 1, "Online snapshots should be sent at the full 10 Hz simulation rate.");
+assert.strictEqual(context.ENEMIES[0].category, "air");
+assert.strictEqual(context.ENEMIES[6].category, "ground");
+assert.strictEqual(context.TOWERS.length, 7);
+assert.strictEqual(context.TOWERS[0].targetClass, "ground");
+assert.strictEqual(context.TOWERS[1].targetClass, "both");
+assert.ok(context.TOWERS[1].bothScale < 1, "The all-purpose laser should trade damage for shield-breaking ground coverage.");
+assert.strictEqual(context.TOWERS[3].targetClass, "both");
+assert.ok(context.TOWERS[3].bothScale < 1, "Universal towers should trade damage for flexibility.");
+assert.strictEqual(context.TOWERS[4].damage, 20, "EMP damage should be tuned down to about 20.");
+assert.strictEqual(context.TOWERS[4].targetClass, "both", "EMP should cover both air and ground units.");
+assert.strictEqual(context.TOWERS[6].targetClass, "air", "The Flak tower must only target air units.");
+const hostId = "11111111-1111-1111-1111-111111111111";
+const friendId = "22222222-2222-2222-2222-222222222222";
+const sentInvites = [];
+let inviteLimitRecord = null;
+const inviteNk = {
+  storageRead(requests) {
+    return requests[0].collection === "private_rooms"
+      ? [{ value: { host_user_id: hostId, match_id: "private-match" } }]
+      : requests[0].collection === "friend_invite_limits" && inviteLimitRecord ? [inviteLimitRecord] : [];
+  },
+  storageWrite(items) {
+    if (items[0].collection === "friend_invite_limits") inviteLimitRecord = { value: items[0].value };
+  },
+  usersGetId() { return [{ displayName: "Commander" }]; },
+  friendsList() { return { friends: [{ state: 0, user: { userId: friendId } }], cursor: "" }; },
+  notificationsSend(items) { sentInvites.push(...items); }
+};
+const inviteCtx = { userId: hostId, username: "pilot_host" };
+assert.strictEqual(JSON.parse(context.rpcInviteFriend(inviteCtx, {}, inviteNk, JSON.stringify({ friend_id: friendId, room_code: "ABC123" }))).accepted, true);
+assert.strictEqual(sentInvites.length, 1);
+assert.strictEqual(sentInvites[0].content.room_code, "ABC123");
+assert.strictEqual(sentInvites[0].content.from, "Commander");
+assert.strictEqual(sentInvites[0].persistent, false, "Game invitations must not remain as stale offline messages.");
+assert.strictEqual(JSON.parse(context.rpcInviteFriend(inviteCtx, {}, inviteNk, JSON.stringify({ friend_id: friendId, room_code: "ABC123" }))).error, "invite_cooldown", "Repeated invitations must be rate limited.");
+assert.strictEqual(sentInvites.length, 1, "A rate-limited invitation must not send another notification.");
+assert.strictEqual(JSON.parse(context.rpcInviteFriend({ userId: friendId }, {}, inviteNk, JSON.stringify({ friend_id: hostId, room_code: "ABC123" }))).accepted, false, "Only the private room host may invite.");
+assert.strictEqual(JSON.parse(context.rpcInviteFriend(inviteCtx, {}, { ...inviteNk, friendsList: () => ({ friends: [] }) }, JSON.stringify({ friend_id: friendId, room_code: "ABC123" }))).accepted, false, "Only mutual friends may be invited.");
+const flakState = {
+  towers: [{ id: 20, type: 6, x: 800, y: 200, owner: 0, level: 1, cooldown: 0 }],
+  enemies: [
+    { id: 401, type: 0, x: 850, y: 200, route_id: 0, path_index: 1, hp: 100, shield: false },
+    { id: 402, type: 6, x: 850, y: 210, route_id: 0, path_index: 1, hp: 100, shield: false }
+  ],
+  credits: [0, 0]
+};
+context.updateTowers(flakState, 1);
+assert.ok(flakState.enemies.find((enemy) => enemy.id === 401).hp < 100, "Flak should damage air units.");
+assert.strictEqual(flakState.enemies.find((enemy) => enemy.id === 402).hp, 100, "Flak must ignore ground units.");
+assert.strictEqual(flakState.shots.length, 1, "Firing towers should publish a visual shot event.");
+assert.strictEqual(flakState.shots[0].tower_id, 20);
+assert.strictEqual(flakState.shots[0].type, 6);
+const shieldTest = { hp: 100, shield: true, shield_hp: 30, max_shield_hp: 30, shield_resistance: 0.28 };
+context.applyDamageToEnemy(shieldTest, 20, 1);
+assert.strictEqual(shieldTest.hp, 100, "Laser damage should drain shield before hull.");
+assert.strictEqual(shieldTest.shield_hp, 10);
+context.applyDamageToEnemy(shieldTest, 20, 1);
+assert.strictEqual(shieldTest.shield, false);
+assert.strictEqual(shieldTest.hp, 90, "Laser damage beyond shield capacity should spill into hull.");
+const priorityState = {
+  towers: [{ id: 1, type: 1, x: 800, y: 120, owner: 0, level: 1, cooldown: 0 }],
+  enemies: [
+    { id: 201, type: 6, x: 850, y: 120, path_index: 1, hp: 100, shield: true, shield_hp: 50, max_shield_hp: 50, shield_resistance: 0.28 },
+    { id: 202, type: 0, x: 950, y: 120, path_index: 1, hp: 100, shield: false }
+  ],
+  credits: [0, 0], wave: 1
+};
+context.updateTowers(priorityState, 1);
+assert.ok(priorityState.enemies[0].shield_hp < 50, "Online lasers should drain a shield before firing at unshielded units.");
+assert.strictEqual(priorityState.enemies[1].hp, 100);
+
+const railgunState = {
+  towers: [{ id: 10, type: 5, x: 300, y: 120, owner: 0, level: 1, cooldown: 0 }],
+  enemies: [
+    { id: 301, type: 0, x: 400, y: 120, path_index: 1, hp: 1000, shield: false },
+    { id: 302, type: 6, x: 500, y: 120, path_index: 1, hp: 1000, shield: false },
+    { id: 303, type: 0, x: 450, y: 150, path_index: 1, hp: 1000, shield: false }
+  ],
+  credits: [0, 0], wave: 1
+};
+context.updateTowers(railgunState, 0.01);
+assert.ok(railgunState.enemies[0].hp < 1000 && railgunState.enemies[1].hp < 1000, "Online railgun should pierce enemies behind its first hit on the same line.");
+assert.strictEqual(railgunState.enemies[2].hp, 1000, "Online railgun should not hit units away from its beam line.");
+
+const empState = {
+  towers: [{ id: 11, type: 4, x: 300, y: 120, owner: 0, level: 1, cooldown: 0 }],
+  enemies: [
+    { id: 401, type: 0, x: 400, y: 120, path_index: 1, hp: 1000, shield: false },
+    { id: 402, type: 6, x: 450, y: 120, path_index: 1, hp: 1000, shield: false },
+    { id: 403, type: 6, x: 570, y: 120, path_index: 1, hp: 1000, shield: false }
+  ],
+  credits: [0, 0], wave: 1
+};
+context.updateTowers(empState, 0.01);
+assert.strictEqual(empState.enemies[0].hp, 980, "EMP should deal 20 damage to its primary target.");
+assert.strictEqual(empState.enemies[1].hp, 980, "EMP should deal its reduced 20 damage to nearby ground units too.");
+assert.strictEqual(empState.enemies[2].hp, 1000, "EMP should not damage units outside its area radius.");
+
 const sent = [];
 const dispatcher = {
  broadcastMessage(opCode, data) {
@@ -67,6 +168,89 @@ assert.strictEqual(privateStats.versions["0.1.0-alpha.2"], 2);
 assert.strictEqual(privateStats.daily_active[context.utcDay(Date.now())], 2);
 assert.throws(() => context.rpcPrivateStats({ userId: "pilot-a" }, logger, metricNk, "{}"), /server-to-server/);

+const promoStorage = new Map();
+let promoVersion = 0;
+let promoCodeSequence = 0;
+let beforePromoDelete = null;
+const promoNk = {
+  uuidv4() {
+    promoCodeSequence += 1;
+    return `${String(promoCodeSequence).padStart(8, "0")}-0000-4000-8000-000000000001`;
+  },
+  sha256Hash(value) { return crypto.createHash("sha256").update(value).digest("hex"); },
+  storageRead(ops) {
+    return ops.map(op => promoStorage.get(`${op.collection}:${op.userId}:${op.key}`)).filter(Boolean);
+  },
+  storageWrite(ops) {
+    for (const op of ops) {
+      const key = `${op.collection}:${op.userId}:${op.key}`;
+      const previous = promoStorage.get(key);
+      if (op.version === "*" && previous) throw new Error("version conflict");
+      if (op.version && op.version !== "*" && (!previous || previous.version !== op.version)) throw new Error("version conflict");
+      promoVersion += 1;
+      promoStorage.set(key, { collection: op.collection, userId: op.userId, key: op.key, value: JSON.parse(JSON.stringify(op.value)), version: String(promoVersion) });
+    }
+  },
+  storageList(userId, collection, limit, cursor) {
+    const objects = Array.from(promoStorage.values())
+      .filter(record => record.userId === userId && record.collection === collection)
+      .slice(0, limit)
+      .map(record => ({ key: record.key, value: JSON.parse(JSON.stringify(record.value)) }));
+    return { objects, cursor: "" };
+  },
+  storageDelete(ops) {
+    for (const op of ops) {
+      const key = `${op.collection}:${op.userId}:${op.key}`;
+      if (beforePromoDelete) beforePromoDelete(key);
+      const previous = promoStorage.get(key);
+      if (!previous || op.version !== previous.version) throw new Error("version conflict");
+      promoStorage.delete(key);
+    }
+  }
+};
+assert.throws(() => context.rpcCreateUnlockCode({ userId: "pilot-a" }, logger, promoNk, JSON.stringify({ reward: "all_maps", max_uses: 1 })), /server-to-server/);
+assert.throws(() => context.rpcCreateUnlockCode({}, logger, promoNk, JSON.stringify({ reward: "all_maps", note: "x".repeat(161) })), /160 characters/);
+const createdPromo = JSON.parse(context.rpcCreateUnlockCode({}, logger, promoNk, JSON.stringify({ reward: "all_maps", max_uses: 2, note: "Für den Multiplayer-Test" })));
+assert.strictEqual(createdPromo.accepted, true);
+assert.strictEqual(createdPromo.code.length, 24);
+assert.strictEqual(createdPromo.note, "Für den Multiplayer-Test");
+assert.strictEqual(JSON.parse(context.rpcListUnlockCodes({}, logger, promoNk, "{}")).codes[0].status, "open");
+assert.throws(() => context.rpcListUnlockCodes({ userId: "pilot-a" }, logger, promoNk, "{}"), /server-to-server/);
+const redeemedPromo = JSON.parse(context.rpcRedeemUnlockCode({ userId: "pilot-promo-a" }, logger, promoNk, JSON.stringify({ code: createdPromo.code })));
+assert.strictEqual(redeemedPromo.accepted, true);
+assert.strictEqual(redeemedPromo.all_maps, true);
+assert.strictEqual(redeemedPromo.all_towers, false);
+const partiallyRedeemed = JSON.parse(context.rpcListUnlockCodes({}, logger, promoNk, "{}")).codes[0];
+assert.strictEqual(partiallyRedeemed.status, "partial");
+assert.strictEqual(partiallyRedeemed.uses, 1);
+assert.strictEqual(partiallyRedeemed.code, createdPromo.code);
+assert.strictEqual(partiallyRedeemed.note, "Für den Multiplayer-Test");
+assert.strictEqual(JSON.parse(context.rpcGetPromoUnlocks({ userId: "pilot-promo-a" }, logger, promoNk, "{}")).all_maps, true);
+assert.strictEqual(JSON.parse(context.rpcRedeemUnlockCode({ userId: "pilot-promo-a" }, logger, promoNk, JSON.stringify({ code: createdPromo.code }))).already_redeemed, true);
+assert.strictEqual(JSON.parse(context.rpcRedeemUnlockCode({ userId: "pilot-promo-b" }, logger, promoNk, JSON.stringify({ code: createdPromo.code }))).accepted, true);
+assert.strictEqual(JSON.parse(context.rpcListUnlockCodes({}, logger, promoNk, "{}")).codes[0].status, "redeemed");
+assert.strictEqual(JSON.parse(context.rpcRedeemUnlockCode({ userId: "pilot-promo-c" }, logger, promoNk, JSON.stringify({ code: createdPromo.code }))).error, "exhausted");
+const usedCodeKey = promoNk.sha256Hash(createdPromo.code);
+assert.throws(() => context.rpcDeleteUnlockCode({ userId: "pilot-a" }, logger, promoNk, JSON.stringify({ code_key: usedCodeKey })), /server-to-server/);
+assert.strictEqual(JSON.parse(context.rpcDeleteUnlockCode({}, logger, promoNk, JSON.stringify({ code_key: usedCodeKey }))).error, "already_used");
+assert.strictEqual(JSON.parse(context.rpcDeleteUnlockCode({}, logger, promoNk, JSON.stringify({ code_key: "bad-key" }))).error, "invalid");
+const unusedPromo = JSON.parse(context.rpcCreateUnlockCode({}, logger, promoNk, JSON.stringify({ reward: "all_towers" })));
+const unusedCodeKey = promoNk.sha256Hash(unusedPromo.code);
+assert.strictEqual(JSON.parse(context.rpcListUnlockCodes({}, logger, promoNk, "{}")).codes.find(entry => entry.code === unusedPromo.code).code_key, unusedCodeKey);
+assert.strictEqual(JSON.parse(context.rpcDeleteUnlockCode({}, logger, promoNk, JSON.stringify({ code_key: unusedCodeKey }))).accepted, true);
+assert.strictEqual(JSON.parse(context.rpcDeleteUnlockCode({}, logger, promoNk, JSON.stringify({ code_key: unusedCodeKey }))).error, "not_found");
+assert.strictEqual(JSON.parse(context.rpcRedeemUnlockCode({ userId: "pilot-promo-d" }, logger, promoNk, JSON.stringify({ code: unusedPromo.code }))).error, "invalid");
+const racingPromo = JSON.parse(context.rpcCreateUnlockCode({}, logger, promoNk, JSON.stringify({ reward: "all_maps" })));
+const racingCodeKey = promoNk.sha256Hash(racingPromo.code);
+beforePromoDelete = key => {
+  beforePromoDelete = null;
+  const previous = promoStorage.get(key);
+  promoVersion += 1;
+  promoStorage.set(key, { ...previous, version: String(promoVersion), value: { ...previous.value, uses: 1, redeemed_users: ["pilot-race"] } });
+};
+assert.strictEqual(JSON.parse(context.rpcDeleteUnlockCode({}, logger, promoNk, JSON.stringify({ code_key: racingCodeKey }))).error, "already_used");
+assert.ok(promoStorage.has(`unlock_codes:${context.SYSTEM_USER_ID}:${racingCodeKey}`));
+
 let leaderboardWrite = null;
 const leaderboardNk = {
  accountGetId() { return { user: { displayName: "Kommandant Ägir" } }; },
@@ -132,9 +316,18 @@ assert.strictEqual(state.credits[1], 250);
 state = context.matchLoop({}, logger, nk, dispatcher, 6, state, [message(presenceA, 13, {})]).state;
 assert.strictEqual(state.wave, 1);
 assert.strictEqual(state.waveActive, true);
+assert.strictEqual(context.snapshot(state, 6).wave_types_remaining.length, state.spawnRemaining);
+const groundSchedule = context.buildWaveSchedule(state, 3, context.wavePopulation(state, 3));
+assert.ok(groundSchedule.some(entry => context.ENEMIES[entry.type].category === "ground"), "Ground units should enter the wave schedule from wave 3.");
 for (let tick = 7; tick < 30; tick++) state = context.matchLoop({}, logger, nk, dispatcher, tick, state, []).state;
 assert.ok(state.enemies.length > 0 || state.spawnRemaining > 0);
 assert.ok(sent.some(entry => entry.opCode === 1 && entry.data.started === true));
+const compactSnapshot = context.snapshot(state, 29);
+const untrimmedSnapshot = { ...compactSnapshot, towers: state.towers, enemies: state.enemies };
+assert.ok(JSON.stringify(compactSnapshot).length < JSON.stringify(untrimmedSnapshot).length, "Frequent snapshots should omit simulation-only properties.");
+assert.ok(compactSnapshot.towers.every(tower => !Object.hasOwn(tower, "cooldown")));
+assert.ok(compactSnapshot.enemies.every(enemy => !Object.hasOwn(enemy, "shield_resistance") && !Object.hasOwn(enemy, "reward")));
+assert.ok(state.towers.every(tower => Object.hasOwn(tower, "cooldown")), "Network serialization must not alter simulation state.");

 const towerA = state.towers.find(tower => tower.owner === 0);
 state = context.matchLoop({}, logger, nk, dispatcher, 30, state, [message(presenceA, 11, { tower_id: towerA.id })]).state;
@@ -32,7 +32,7 @@ func _run() -> void:
 	assert(not info.is_exception(), "Die Godot-Anbindung muss Server-RPCs erreichen.")
 	var info_data = JSON.parse_string(info.payload)
 	assert(info_data is Dictionary and info_data.get("status") == "online", "Der Server muss seinen Onlinestatus melden.")
-	assert(info_data.get("version") == "0.23", "Der Server muss die aktuelle Runtime 0.23 geladen haben: %s" % info_data)
+	assert(info_data.get("version") == "0.25", "Der Server muss die aktuelle Runtime 0.25 geladen haben: %s" % info_data)

 	var deletion_client: NakamaClient = nakama.create_client("voidbastion-public-v1", test_host, test_port, test_scheme, 5, NakamaLogger.LOG_LEVEL.ERROR)
 	var deletion_session: NakamaSession = await deletion_client.authenticate_device_async("voidbastion_delete_test_" + suffix, "delete_test_" + suffix, true)
@@ -51,13 +51,13 @@ func _run() -> void:
 	var public_leaderboard_name := "Rangpilot %s" % suffix.right(6)
 	var renamed_a = await client_a.rpc_async(session_a, "update_display_name", JSON.stringify({"display_name": public_leaderboard_name}))
 	assert(not renamed_a.is_exception() and bool(JSON.parse_string(renamed_a.payload).get("accepted", false)), "Der Ranglistenpilot muss einen öffentlichen Namen setzen können.")
-	var run_payload := JSON.stringify({"map": 1, "difficulty": 1, "mode": "mission", "wave": 4, "score": 4700, "client_version": "0.23-integration"})
+	var run_payload := JSON.stringify({"map": 1, "difficulty": 1, "mode": "mission", "wave": 4, "score": 4700, "client_version": "0.25-integration"})
 	var submitted = await client_a.rpc_async(session_a, "submit_run", run_payload)
 	assert(not submitted.is_exception(), "Ein plausibles Ergebnis muss serverseitig angenommen werden.")
-	var records = await client_a.list_leaderboard_records_async(session_a, "mission_map1_difficulty1", null, null, 10)
-	assert(not records.is_exception() and records.records.size() >= 1, "Das Ergebnis muss über das Godot-SDK aus der Rangliste lesbar sein.")
+	var records = await client_a.list_leaderboard_records_async(session_a, "mission_map1_difficulty1", [session_a.user_id], null, 10)
+	assert(not records.is_exception() and (records.records.size() >= 1 or records.owner_records.size() >= 1), "Das Ergebnis muss über das Godot-SDK aus der Rangliste lesbar sein.")
 	var own_record = null
-	for record in records.records:
+	for record in records.owner_records:
 		if record.owner_id == session_a.user_id:
 			own_record = record
 			break
@@ -67,6 +67,17 @@ func _run() -> void:
 	var socket_b: NakamaSocket = nakama.create_socket_from(client_b)
 	assert(not (await socket_a.connect_async(session_a, true, 5)).is_exception(), "Spieler A benötigt eine Echtzeitverbindung.")
 	assert(not (await socket_b.connect_async(session_b, true, 5)).is_exception(), "Spieler B benötigt eine Echtzeitverbindung.")
+	var friend_request = await client_a.add_friends_async(session_a, null, PackedStringArray([session_b.username]))
+	assert(not friend_request.is_exception(), "Spieler A muss eine Freundschaftsanfrage senden können.")
+	var friend_accept = await client_b.add_friends_async(session_b, PackedStringArray([session_a.user_id]))
+	assert(not friend_accept.is_exception(), "Spieler B muss die Freundschaftsanfrage bestätigen können.")
+	var friend_list = await client_a.list_friends_async(session_a, 0, 100)
+	assert(not friend_list.is_exception() and friend_list.friends.size() == 1 and friend_list.friends[0].user.id == session_b.user_id,
+		"Die bestätigte Freundschaft muss beim Gastgeber sichtbar sein.")
+	var received_invites: Array = []
+	socket_b.received_notification.connect(func(note):
+		if int(note.code) == 101:
+			received_invites.append(JSON.parse_string(note.content)))
 	socket_a.received_matchmaker_matched.connect(func(value): matched_a = value)
 	socket_b.received_matchmaker_matched.connect(func(value): matched_b = value)
 	socket_a.received_match_state.connect(func(value): _capture_snapshot(value, true))
@@ -124,6 +135,14 @@ func _run() -> void:
 	assert(room_code.length() == 6 and not private_match_id.is_empty(), "Der Server muss einen sechsstelligen Raumcode und eine Partie liefern.")
 	var private_match_a = await socket_a.join_match_async(private_match_id)
 	assert(not private_match_a.is_exception(), "Der Gastgeber muss seinem privaten Raum beitreten können.")
+	var invite = await client_a.rpc_async(session_a, "invite_friend", JSON.stringify({"friend_id": session_b.user_id, "room_code": room_code}))
+	assert(not invite.is_exception() and bool(JSON.parse_string(invite.payload).get("accepted", false)), "Der Gastgeber muss einen bestätigten Freund einladen können.")
+	for attempt in 30:
+		if not received_invites.is_empty():
+			break
+		await create_timer(0.05).timeout
+	assert(not received_invites.is_empty() and received_invites[0] is Dictionary and String(received_invites[0].get("room_code", "")) == room_code,
+		"Die Einladung muss als Echtzeitbenachrichtigung mit dem richtigen Raumcode ankommen.")
 	var found_room = await client_b.rpc_async(session_b, "join_private_room", JSON.stringify({"room_code": room_code.to_lower()}))
 	assert(not found_room.is_exception(), "Der Mitspieler muss den Raumcode unabhängig von Groß-/Kleinschreibung finden können.")
 	var found_data = JSON.parse_string(found_room.payload)
@@ -0,0 +1,83 @@
+extends Node
+
+
+func _ready() -> void:
+	call_deferred("_run")
+
+
+func _run() -> void:
+	var game = load("res://main.tscn").instantiate()
+	get_tree().root.add_child(game)
+	await get_tree().process_frame
+	game.ui_language = "en"
+	assert(game._ui("FREUNDESLISTE") == "FRIENDS")
+	assert(game._ui("WELLE") == "WAVE")
+	game.ui_language = "de"
+	assert(game._ui("FREUNDESLISTE") == "FREUNDESLISTE")
+	game._on_match_invite_received({"room_code": "ABC123", "from": "Testpilot"})
+	assert(game.pending_match_invite.room_code == "ABC123")
+	game.pending_match_invite.clear()
+	game.friend_return_mode = "matchmaking"
+	game.multiplayer_manager.matchmaking_mode = "private_host"
+	game.multiplayer_manager.matchmaking_state = "hosting"
+	game.multiplayer_manager.private_room_code = "ABC123"
+	assert(game._can_invite_friends())
+	game.multiplayer_manager.matchmaking_state = "offline"
+	assert(not game._can_invite_friends(), "Ein alter Raumcode darf keine Einladung mehr ermöglichen.")
+	game.coop_online_mode = true
+	var base_snapshot := {
+		"difficulty": 1, "reactor_lives": 30, "wave": 1, "wave_active": true,
+		"enemies_to_spawn": 0, "wave_types_remaining": [], "towers": [],
+		"enemies": [{"id": 4, "type": 0, "x": 100.0, "y": 200.0, "hp": 40.0,
+			"max_hp": 40.0, "shield": false, "boss": false}], "shots": []
+	}
+	game._apply_online_snapshot(base_snapshot)
+	assert(game.enemies.size() == 1)
+	assert(game.enemies[0].pos == Vector2(100, 200))
+	var first_enemy: Dictionary = game.enemies[0]
+	var next_snapshot: Dictionary = base_snapshot.duplicate(true)
+	next_snapshot["enemies"][0]["x"] = 200.0
+	next_snapshot["enemies"][0]["hp"] = 25.0
+	game._apply_online_snapshot(next_snapshot)
+	assert(is_same(first_enemy, game.enemies[0]), "Gegnerdaten sollen zwischen Paketen wiederverwendet werden.")
+	game._update_online_interpolation(0.05)
+	assert(game.enemies[0].pos.x > 100.0 and game.enemies[0].pos.x < 200.0,
+		"Die Position soll zwischen zwei Serverständen gleichmäßig übergehen.")
+	game._update_online_interpolation(0.1)
+	assert(is_equal_approx(game.enemies[0].pos.x, 200.0))
+	game.online_projectiles.append({"pos": Vector2.ZERO, "target": Vector2(30, 0), "speed": 920.0, "color": Color.WHITE})
+	game._update_online_projectiles(0.1)
+	assert(game.online_projectiles.is_empty(), "Geschosse dürfen bei einem langen Frame nicht am Ziel vorbeipendeln.")
+	var online_manager: OnlineManager = game.get_node("OnlineManager")
+	var received: Array = []
+	online_manager.match_snapshot_received.connect(func(snapshot: Dictionary) -> void: received.append(snapshot))
+	online_manager.pending_snapshot_payloads.append(JSON.stringify({"tick": 1, "shots": [{"id": 1}]}))
+	online_manager.pending_snapshot_payloads.append(JSON.stringify({"tick": 2, "shots": [{"id": 2}]}))
+	online_manager._flush_pending_snapshots()
+	assert(received.size() == 1 and received[0].tick == 2, "Nur der neueste Spielstand darf angewendet werden.")
+	assert(received[0].shots.size() == 2, "Schusseffekte aus zusammengefassten Spielständen müssen erhalten bleiben.")
+	received.clear()
+	online_manager.current_match = {"match_id": "test-match"}
+	for tick in 8:
+		online_manager._on_match_state({"match_id": "test-match", "op_code": online_manager.OP_SNAPSHOT,
+			"data": JSON.stringify({"tick": tick, "shots": [{"id": tick}]})})
+	assert(online_manager.pending_snapshot_payloads.size() == online_manager.MAX_PENDING_SNAPSHOTS,
+		"Die Warteschlange muss auch nach einem längeren Rückstau begrenzt bleiben.")
+	online_manager._flush_pending_snapshots()
+	assert(received.size() == 1 and received[0].tick == 7)
+	assert(received[0].shots.size() == online_manager.MAX_PENDING_SNAPSHOTS)
+	game._select_map(0)
+	game._prepare_draw_geometry()
+	assert(not game.draw_geometry_dirty and not game.road_tile_cache.is_empty())
+	assert(not game.build_cell_cache.is_empty())
+	game._select_map(1)
+	assert(game.draw_geometry_dirty, "Ein Kartenwechsel muss die Weggeometrie erneuern.")
+	game._prepare_draw_geometry()
+	assert(not game.draw_geometry_dirty)
+	game.coop_mode = true
+	game._configure_coop_arena()
+	game._prepare_draw_geometry()
+	var partner_cells: Array = game.build_cell_cache.filter(func(cell: Dictionary) -> bool: return cell.partner)
+	assert(not partner_cells.is_empty(), "Die gespiegelte Koop-Seite braucht eigene Baufelder.")
+	print("VOID_BASTION_ONLINE_SNAPSHOT_OK")
+	get_tree().quit()
@@ -0,0 +1 @@
+uid://cg5nghnbri5bo
@@ -0,0 +1,6 @@
+[gd_scene load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://tests/online_snapshot_test.gd" id="1_test"]
+
+[node name="OnlineSnapshotTest" type="Node"]
+script = ExtResource("1_test")
@@ -29,12 +29,18 @@ func _run() -> void:
 	var ads_manager = game.get_node("AdsManager")
 	var account_manager = game.get_node("AccountManager")
 	var multiplayer_manager = game.get_node("MultiplayerManager")
+	game.set("core_crystals", 0)
+	game.call("_adjust_core_crystals", 25)
+	assert(game.get("core_crystals") == 25, "Der Entwicklermodus muss Testkristalle hinzufügen können.")
+	game.call("_adjust_core_crystals", -25)
+	game.call("_adjust_core_crystals", -25)
+	assert(game.get("core_crystals") == 0, "Der Entwicklermodus muss Kristalle abziehen können, ohne unter null zu fallen.")
 	assert(game.get("MAP_NAMES").size() == 7, "Es müssen sieben Karten vorhanden sein.")
 	assert(game.get("MAP_TEXTURES").size() == 7, "Jede Karte benötigt einen eigenen Hintergrund.")
 	assert(game.get("map_buttons").size() == 7, "Alle sieben Kartenvorschauen müssen gleichzeitig auswählbar sein.")
 	game.set("unlocked_maps", [0, 1, 2])
-	assert(game.get("TOWER_DATA").size() == 6, "Das Arsenal muss sechs unterschiedliche Turmtypen enthalten.")
-	assert(game.get("tower_buttons").size() == 6, "Alle sechs Türme müssen gleichzeitig in der unteren Baumenüleiste sichtbar sein.")
+	assert(game.get("TOWER_DATA").size() == 7, "Das Arsenal muss sieben unterschiedliche Turmtypen enthalten.")
+	assert(game.get("tower_buttons").size() == 7, "Alle sieben Türme müssen gleichzeitig in der unteren Baumenüleiste sichtbar sein.")
 	game.call("_handle_pointer", Vector2(760, 815), false)
 	assert(game.get("game_mode") == "store", "Der interne Shop muss direkt aus dem Hauptmenü erreichbar sein.")
 	await process_frame
@@ -69,7 +75,8 @@ func _run() -> void:
 	assert(game.get("menu_step") == "map", "Die Missionsvorbereitung benötigt eine Rückkehr zur Kartenauswahl.")
 	game.set("unlocked_towers", [0, 1, 2])
 	game.set("game_mode", "playing")
-	game.call("_handle_pointer", game.get("tower_buttons")[3].get_center(), false)
+	var locked_tower_slot: int = game.call("_tower_display_order").find(3)
+	game.call("_handle_pointer", game.get("tower_buttons")[locked_tower_slot].get_center(), false)
 	assert(game.get("game_mode") == "store", "Ein gesperrter Turm muss den Shop auch aus einer laufenden Mission öffnen.")
 	game.call("_handle_pointer", game.get("shop_back_button").get_center(), false)
 	assert(game.get("game_mode") == "playing", "Der Shop-Zurück-Button muss in die laufende Mission zurückführen.")
@@ -135,10 +142,11 @@ func _run() -> void:
 	assert(game.get("game_mode") == "menu", "Die Bestenliste benötigt einen funktionierenden Zurück-Button.")
 	assert(not account_manager.player_id.is_empty(), "Beim ersten Start muss automatisch ein stabiles Gastprofil angelegt werden.")
 	assert(not account_manager.display_name.is_empty(), "Das Gastprofil benötigt einen sichtbaren Pilotennamen.")
-	assert(game.call("_app_version") == "0.1.0-alpha.4", "Profil, Installer und Online-Übertragung müssen dieselbe Alpha-Version verwenden.")
+	var current_version: String = str(ProjectSettings.get_setting("application/config/version", ""))
+	assert(game.call("_app_version") == current_version and not current_version.is_empty(), "Profil und Online-Übertragung müssen dieselbe Alpha-Version verwenden.")
 	var support_url: String = game.call("_support_email_url")
 	assert(support_url.begins_with("mailto:support@gergames.de?"), "Die Feedback-Schaltfläche muss die öffentliche Supportadresse verwenden.")
-	assert(support_url.contains("0.1.0-alpha.4") and support_url.contains(account_manager.short_id()), "Die Support-Mail muss Version und gekürzte Spieler-ID zur Fehlerzuordnung enthalten.")
+	assert(support_url.contains(current_version) and support_url.contains(account_manager.short_id()), "Die Support-Mail muss Version und gekürzte Spieler-ID zur Fehlerzuordnung enthalten.")
 	account_manager.storage_enabled = false
 	var original_display_name: String = account_manager.display_name
 	assert(account_manager.validate_display_name("Kommandant Ägir").is_empty(), "Ein normaler internationaler Spielername muss gültig sein.")
@@ -152,14 +160,14 @@ func _run() -> void:
 	assert(account_manager.get_map_best_wave(0, false) >= 3, "Die Profilansicht muss den gespeicherten Missionsbestwert lesen können.")
 	assert(not ads_manager.mobile_ads_supported, "Auf Windows müssen Anzeigen vollständig deaktiviert bleiben.")
 	var update_manager = game.get_node("UpdateManager")
-	assert(update_manager.call("_is_newer_version", "0.1.0-alpha.4", "0.1.0-alpha.3"), "Eine neuere Alpha-Version muss als Update erkannt werden.")
+	assert(update_manager.call("_is_newer_version", "0.1.0-alpha.6", "0.1.0-alpha.5"), "Eine neuere Alpha-Version muss als Update erkannt werden.")
 	assert(update_manager.call("_is_newer_version", "0.1.0", "0.1.0-alpha.2"), "Eine stabile Version muss neuer als ihre Alpha-Version sein.")
-	assert(not update_manager.call("_is_newer_version", "0.1.0-alpha.4", "0.1.0-alpha.4"), "Die installierte Version darf nicht als Update angeboten werden.")
+	assert(not update_manager.call("_is_newer_version", "0.1.0-alpha.6", "0.1.0-alpha.6"), "Die installierte Version darf nicht als Update angeboten werden.")
 	var announced_update := {}
 	update_manager.update_available.connect(func(info: Dictionary): announced_update.merge(info, true))
-	var fake_release_body := JSON.stringify([{"tag_name": "v0.1.0-alpha.5", "name": "Alpha.5", "draft": false, "assets": [{"name": "Void-Bastion-Setup-x64.exe", "browser_download_url": "https://git.dominicspringer.de/public-test.exe"}]}]).to_utf8_buffer()
+	var fake_release_body := JSON.stringify([{"tag_name": "v9.0.0", "name": "Future test release", "draft": false, "assets": [{"name": "Void-Bastion-Setup-x64.exe", "browser_download_url": "https://git.dominicspringer.de/public-test.exe"}]}]).to_utf8_buffer()
 	update_manager.call("_on_request_completed", HTTPRequest.RESULT_SUCCESS, 200, PackedStringArray(), fake_release_body)
-	assert(announced_update.get("version") == "0.1.0-alpha.5", "Die Update-Prüfung muss eine neuere öffentliche Version ankündigen.")
+	assert(announced_update.get("version") == "9.0.0", "Die Update-Prüfung muss eine neuere öffentliche Version ankündigen.")
 	assert(str(announced_update.get("url", "")).begins_with("https://git.dominicspringer.de/"), "Der Update-Hinweis darf nur einen öffentlichen Download-Link öffnen.")
 	assert(game.get("path_points").size() == 9, "Bastion Prime sollte mit einer eigenen Einfahrt im Reaktor enden.")
 	_assert_grid_aligned_path(game.get("path_points"), "Bastion Prime")
@@ -222,16 +230,17 @@ func _run() -> void:
 	game.set("selected_difficulty", 0)
 	game.call("_start_game")
 	assert(game.get("credits") == 450 and game.get("reactor_lives") == 20, "Leicht muss dem bisherigen Balancing entsprechen.")
-	game.call("_handle_pointer", Vector2(1180, 45), false)
+	game.call("_handle_pointer", game.get("speed_button").get_center(), false)
 	assert(game.get("speed_dropdown_open"), "Die Spielgeschwindigkeit muss über eine Auswahl bedienbar sein.")
-	game.call("_handle_pointer", Vector2(1190, 198), false)
+	game.call("_handle_pointer", game.call("_speed_option_rect", 4).get_center(), false)
 	assert(is_equal_approx(game.get("game_speed"), 5.0), "Die Geschwindigkeitsauswahl muss bis 5× reichen.")
 	game.set("game_speed", 1.0)
-	game.call("_handle_pointer", Vector2(1330, 82), false)
+	game.call("_handle_pointer", game.get("auto_wave_button").get_center(), false)
 	assert(game.get("auto_start_waves"), "Der automatische Wellenstart muss per Checkbox aktivierbar sein.")
-	game.call("_handle_pointer", Vector2(1330, 82), false)
+	game.call("_handle_pointer", game.get("auto_wave_button").get_center(), false)
 	assert(not game.get("auto_start_waves"), "Der automatische Wellenstart muss per Checkbox abschaltbar sein.")
-	game.call("_handle_pointer", Vector2(1110, 45), false)
+	game.call("_handle_pointer", game.get("pause_button").get_center(), false)
+	game.call("_handle_pointer", game.get("pause_exit_button").get_center(), false)
 	assert(game.get("game_mode") == "menu", "Der Zurück-Button muss eine laufende Runde abbrechen und zum Kartenmenü führen.")
 	assert(game.get("towers").is_empty() and game.get("enemies").is_empty(), "Beim Abbruch müssen alle Einheiten der laufenden Runde entfernt werden.")
 	game.call("_start_game")
@@ -264,6 +273,62 @@ func _run() -> void:
 	assert(game.get("enemies_to_spawn") > 9, "Mittel muss mehr Gegner als Leicht erzeugen.")
 	game.set("selected_difficulty", 2)
 	game.call("_start_game")
+	assert(game.get("credits") == 340 and game.get("reactor_lives") == 12, "Schwer muss mit knapperen Startressourcen und weniger Reaktorleben beginnen.")
+	assert(int(game.call("_difficulty").crystals) == 12, "Ein Sieg auf Schwer muss den höheren Kristallbonus gewähren.")
+	assert(game.get("ENEMY_DATA").size() == 9, "Drei zusätzliche Gegnerrollen müssen im Spiel verfügbar sein.")
+	assert(game.call("_enemy_category", 0) == "air" and game.call("_enemy_category", 6) == "ground", "Luft- und Bodeneinheiten müssen eindeutig klassifiziert sein.")
+	assert(not game.call("_tower_can_target", 0, 0) and game.call("_tower_can_target", 1, 0) and game.call("_tower_can_target", 1, 6) and game.call("_tower_can_target", 5, 6), "Kinetik muss auf Boden beschränkt sein; Laser und Railgun dürfen beide Kategorien angreifen.")
+	assert(game.call("_enemy_texture", 6).get_width() > 0 and game.call("_enemy_texture", 8).get_height() > 0, "Bodeneinheiten benötigen eigene lesbare Grafiken.")
+	assert(game.get("TOWER_DATA")[0].target_class == "ground" and game.get("TOWER_DATA")[1].target_class == "both", "Der Laser muss neben Luft- auch Bodenziele angreifen können.")
+	assert(game.get("TOWER_DATA")[1].both_damage_scale < 1.0 and game.get("TOWER_DATA")[3].both_damage_scale < 1.0 and game.get("TOWER_DATA")[5].both_damage_scale < 1.0, "Laser, Plasma und Railgun müssen für ihre Mehrzweckfähigkeit einen Schadensmultiplikator erhalten.")
+	assert(game.get("TOWER_DATA")[4].damage == 20.0 and game.get("TOWER_DATA")[4].target_class == "both", "EMP muss Luft- und Bodenziele mit rund 20 Schaden erfassen.")
+	assert(game.call("_tower_display_order") == [6, 0, 2, 1, 3, 4, 5], "Die Turmauswahl muss zuerst Luft-, dann Boden- und anschließend Mehrzwecktürme gruppieren.")
+	assert(game.call("_tower_class_color", 0).g > game.call("_tower_class_color", 0).r and game.call("_tower_class_color", 1).b > game.call("_tower_class_color", 1).r, "Bodenfelder müssen grün und Mehrzweckfelder blau-cyan eingefärbt sein.")
+	game.get("enemies").clear()
+	var rail_front := {"id": 96001, "type": 0, "pos": Vector2(400, 300), "hp": 1000.0, "max_hp": 1000.0, "flash": 0.0, "shield": false, "reward": 1}
+	var rail_behind := {"id": 96002, "type": 6, "pos": Vector2(500, 300), "hp": 1000.0, "max_hp": 1000.0, "flash": 0.0, "shield": false, "reward": 1}
+	var rail_offline := {"id": 96003, "type": 0, "pos": Vector2(450, 326), "hp": 1000.0, "max_hp": 1000.0, "flash": 0.0, "shield": false, "reward": 1}
+	game.get("enemies").append_array([rail_front, rail_behind, rail_offline])
+	game.call("_fire_tower", {"type": 5, "level": 1, "pos": Vector2(300, 300), "owner": 0}, rail_front)
+	assert(rail_front.hp < 1000.0 and rail_behind.hp < 1000.0 and is_equal_approx(rail_offline.hp, 1000.0), "Der Railgun-Strahl muss Gegner hinter dem Ziel auf der Linie durchschlagen, aber keine Ziele neben der Linie treffen.")
+	assert(game.get("beams")[-1].piercing and game.get("beams")[-1].color == Color("c86bff"), "Der durchschlagende Railgun-Strahl muss sichtbar lila sein.")
+	game.get("enemies").clear()
+	game.get("projectiles").clear()
+	var emp_air := {"id": 96101, "type": 0, "pos": Vector2(500, 500), "hp": 1000.0, "max_hp": 1000.0, "flash": 0.0, "shield": false, "reward": 1}
+	var emp_ground := {"id": 96102, "type": 6, "pos": Vector2(550, 500), "hp": 1000.0, "max_hp": 1000.0, "flash": 0.0, "shield": false, "reward": 1}
+	var emp_outside := {"id": 96103, "type": 6, "pos": Vector2(700, 500), "hp": 1000.0, "max_hp": 1000.0, "flash": 0.0, "shield": false, "reward": 1}
+	game.get("enemies").append_array([emp_air, emp_ground, emp_outside])
+	game.call("_fire_tower", {"type": 4, "level": 1, "pos": Vector2(400, 500), "owner": 0}, emp_air)
+	game.get("projectiles")[-1].speed = 0.0
+	game.get("projectiles")[-1].pos = emp_air.pos
+	game.call("_update_projectiles", 0.01)
+	assert(is_equal_approx(emp_air.hp, 980.0) and is_equal_approx(emp_ground.hp, 980.0) and is_equal_approx(emp_outside.hp, 1000.0), "Der EMP muss Luft und Boden im 118er-Radius jeweils um 20 treffen und Gegner außerhalb verschonen.")
+	game.get("enemies").clear()
+	game.set("path_points", PackedVector2Array([Vector2(0, 0), Vector2(1000, 0), Vector2(1600, 0)]))
+	game.get("enemies").clear()
+	var shield_target := {"id": 201, "type": 6, "pos": Vector2(850, 0), "path_index": 1, "hp": 100.0, "shield": true}
+	var unshielded_target := {"id": 202, "type": 6, "pos": Vector2(950, 0), "path_index": 1, "hp": 500.0, "shield": false}
+	game.get("enemies").append(shield_target)
+	game.get("enemies").append(unshielded_target)
+	assert(game.call("_find_target", {"type": 1, "level": 1, "pos": Vector2(800, 0)}).id == 201, "Lasertürme müssen unabhängig vom Fortschritt immer zuerst ein Schildziel in Reichweite wählen.")
+	assert(game.call("_find_target", {"type": 0, "level": 1, "pos": Vector2(800, 0), "target_priority": "strongest"}).id == 202, "Die Priorität MEISTE HP muss das Ziel mit den meisten Lebenspunkten wählen.")
+	assert(game.call("_find_target", {"type": 0, "level": 1, "pos": Vector2(800, 0), "target_priority": "last"}).id == 201, "Die Priorität LETZTE muss die Einheit mit dem geringsten Wegfortschritt wählen.")
+	game.get("towers").clear()
+	game.get("towers").append({"type": 0, "target_priority": "first"})
+	game.set("selected_tower_index", 0)
+	game.call("_cycle_selected_tower_priority")
+	assert(game.get("towers")[0].target_priority == "last", "Die Zielpriorität eines ausgewählten Turms muss umstellbar sein.")
+	game.set("selected_tower_index", -1)
+	game.get("towers").clear()
+	game.get("enemies").clear()
+	game.call("_select_map", 0)
+	assert(game.call("_enemy_type_for_wave", 3, 0.9, false) == 3, "Auf Schwer muss der Abfangjäger ab Welle 3 auftreten.")
+	assert(game.call("_enemy_type_for_wave", 5, 0.85, false) == 4, "Auf Schwer muss der Schildkreuzer ab Welle 5 auftreten.")
+	assert(game.call("_enemy_type_for_wave", 8, 0.95, false) == 5, "Auf Schwer muss der Belagerer ab Welle 8 auftreten.")
+	game.set("selected_difficulty", 1)
+	var medium_late_health: float = game.call("_enemy_health_scale", 12, false)
+	game.set("selected_difficulty", 2)
+	assert(game.call("_enemy_health_scale", 12, false) > medium_late_health, "Schwer muss ab der Missionsmitte stärker skalieren als Mittel.")
 	game.set("wave", 1)
 	game.set("enemies_to_spawn", 2)
 	game.call("_spawn_enemy")
@@ -272,13 +337,25 @@ func _run() -> void:
 	game.set("wave", 3)
 	game.call("_start_wave")
 	assert(game.get("enemies_to_spawn") > 15, "Ab Welle 4 muss die Gegnerzahl merklich steigen.")
+	var preview_types: Array[int] = game.call("_wave_preview_types", 3)
+	assert(preview_types.has(6) and preview_types.has(0), "Die Vorschau muss Luft- und Bodentypen der gleichen Welle zeigen.")
+	var preview_summary: Dictionary = game.call("_wave_preview_summary", 3)
+	assert(preview_summary.total == preview_types.size() and preview_summary.air + preview_summary.ground == preview_summary.total, "Die Vorschau muss die Gesamtzahl der Schiffe sowie die korrekten Luft-/Bodenanteile zählen.")
+	assert(game.get("wave_type_schedule").size() == game.get("enemies_to_spawn"), "Die Vorschau und der tatsächliche Spawnplan müssen übereinstimmen.")
+	var test_enemy := {"hp": 100.0, "max_hp": 100.0, "base_max_hp": 100.0, "type": 0, "flash": 0.0, "pos": Vector2.ZERO}
+	game.get("enemies").append(test_enemy)
+	game.call("_set_enemy_strength_multiplier", 1.6)
+	assert(is_equal_approx(test_enemy.max_hp, 160.0) and is_equal_approx(test_enemy.hp, 160.0), "Der Testmultiplikator muss die Hülle laufender Gegner anpassen.")
+	game.call("_set_enemy_strength_multiplier", 1.0)
 	game.get("enemies").clear()
-	var shielded_enemy := {"hp": 1000.0, "max_hp": 1000.0, "flash": 0.0, "id": 98001, "type": 0, "pos": Vector2.ZERO, "speed": 1.0, "reward": 1, "boss": false, "size_scale": 1.0, "shield": true}
+	var shielded_enemy := {"hp": 1000.0, "max_hp": 1000.0, "flash": 0.0, "id": 98001, "type": 0, "pos": Vector2.ZERO, "speed": 1.0, "reward": 1, "boss": false, "size_scale": 1.0, "shield": true, "shield_hp": 50.0, "max_shield_hp": 50.0, "shield_resistance": 0.28}
 	game.get("enemies").append(shielded_enemy)
 	game.call("_apply_damage", shielded_enemy, 100.0, 0, 0)
 	assert(is_equal_approx(shielded_enemy.hp, 972.0), "Schilde müssen kinetischen Schaden deutlich reduzieren, aber nicht vollständig blockieren.")
-	game.call("_apply_damage", shielded_enemy, 100.0, 0, 1)
-	assert(is_equal_approx(shielded_enemy.hp, 872.0), "Laser müssen Schildgegner effektiv beschädigen.")
+	game.call("_apply_damage", shielded_enemy, 30.0, 0, 1)
+	assert(is_equal_approx(shielded_enemy.hp, 972.0) and is_equal_approx(shielded_enemy.shield_hp, 20.0), "Laser müssen das Schildleben statt der Hülle abbauen.")
+	game.call("_apply_damage", shielded_enemy, 30.0, 0, 1)
+	assert(not shielded_enemy.shield and is_equal_approx(shielded_enemy.hp, 962.0), "Der Laser muss beim Schildbruch überschüssigen Schaden auf die Hülle übertragen.")
 	game.get("enemies").clear()
 	game.set("wave", 5)
 	game.set("reactor_lives", 12)
@@ -295,10 +372,12 @@ func _run() -> void:
 	game.set("wave", 4)
 	game.call("_start_wave")
 	game.set("enemies_to_spawn", 1)
+	game.set("wave_spawn_index", 0)
+	game.set("wave_type_schedule", game.call("_build_wave_schedule", 5, 1))
 	game.call("_spawn_enemy")
 	var boss: Dictionary = game.get("enemies")[-1]
 	assert(boss.boss, "Jede fünfte Welle sollte ein Kommandoschiff erzeugen.")
-	assert(boss.type == 2, "Das Kommandoschiff sollte die schwere Schiffsklasse verwenden.")
+	assert(boss.type == 5, "Das Kommandoschiff sollte die schwere Belagerer-Klasse verwenden.")
 	game.call("_start_game")
 	var crystals_before: int = game.get("core_crystals")
 	game.set("wave", 15)
@@ -0,0 +1,68 @@
+extends SceneTree
+
+var received_invites: Array = []
+
+
+func _initialize() -> void:
+	call_deferred("_run")
+
+
+func _run() -> void:
+	var nakama = root.get_node("Nakama")
+	var host := OS.get_environment("VOID_BASTION_TEST_HOST")
+	var scheme := OS.get_environment("VOID_BASTION_TEST_SCHEME")
+	var port_text := OS.get_environment("VOID_BASTION_TEST_PORT")
+	if host.is_empty():
+		host = "192.168.178.20"
+	if scheme.is_empty():
+		scheme = "http"
+	var port := int(port_text) if not port_text.is_empty() else 7350
+	var client_a: NakamaClient = nakama.create_client("voidbastion-public-v1", host, port, scheme, 5, NakamaLogger.LOG_LEVEL.ERROR)
+	var client_b: NakamaClient = nakama.create_client("voidbastion-public-v1", host, port, scheme, 5, NakamaLogger.LOG_LEVEL.ERROR)
+	var suffix := str(Time.get_ticks_usec())
+	var session_a: NakamaSession = await client_a.authenticate_device_async("social_test_a_" + suffix, "social_a_" + suffix, true)
+	var session_b: NakamaSession = await client_b.authenticate_device_async("social_test_b_" + suffix, "social_b_" + suffix, true)
+	assert(not session_a.is_exception() and not session_b.is_exception(), "Beide Testkonten müssen sich anmelden können.")
+	var socket_a: NakamaSocket = nakama.create_socket_from(client_a)
+	var socket_b: NakamaSocket = nakama.create_socket_from(client_b)
+	assert(not (await socket_a.connect_async(session_a, true, 5)).is_exception())
+	assert(not (await socket_b.connect_async(session_b, true, 5)).is_exception())
+	socket_b.received_notification.connect(func(note):
+		if int(note.code) == 101:
+			received_invites.append(JSON.parse_string(note.content)))
+	var requested = await client_a.add_friends_async(session_a, null, PackedStringArray([session_b.username]))
+	assert(not requested.is_exception(), "Eine Freundschaftsanfrage muss gesendet werden können.")
+	var accepted = await client_b.add_friends_async(session_b, PackedStringArray([session_a.user_id]))
+	assert(not accepted.is_exception(), "Die Anfrage muss angenommen werden können.")
+	var friend_list = await client_a.list_friends_async(session_a, 0, 100)
+	assert(not friend_list.is_exception() and friend_list.friends.size() == 1 and friend_list.friends[0].user.id == session_b.user_id,
+		"Die gegenseitige Freundschaft muss auf dem Server gespeichert sein.")
+	var followed = await socket_a.follow_users_async(PackedStringArray([session_b.user_id]), PackedStringArray())
+	assert(not followed.is_exception(), "Der Freundesstatus muss abonnierbar sein.")
+	assert(not (await socket_b.update_status_async("playing")).is_exception(), "Der Im-Spiel-Status muss gesetzt werden können.")
+	var created = await client_a.rpc_async(session_a, "create_private_room", JSON.stringify({"difficulty": 1}))
+	assert(not created.is_exception(), "Ein privater Raum muss erstellbar sein.")
+	var room: Dictionary = JSON.parse_string(created.payload)
+	var code := String(room.get("room_code", ""))
+	assert(code.length() == 6)
+	var joined = await socket_a.join_match_async(String(room.get("match_id", "")))
+	assert(not joined.is_exception(), "Der Gastgeber muss den privaten Raum betreten können.")
+	var invited = await client_a.rpc_async(session_a, "invite_friend", JSON.stringify({"friend_id": session_b.user_id, "room_code": code}))
+	assert(not invited.is_exception() and bool(JSON.parse_string(invited.payload).get("accepted", false)),
+		"Der Gastgeber muss einen bestätigten Freund einladen können.")
+	for attempt in 40:
+		if not received_invites.is_empty():
+			break
+		await create_timer(0.05).timeout
+	assert(not received_invites.is_empty() and received_invites[0] is Dictionary and String(received_invites[0].get("room_code", "")) == code,
+		"Die Echtzeit-Einladung muss den Raumcode enthalten.")
+	var unauthorized = await client_b.rpc_async(session_b, "invite_friend", JSON.stringify({"friend_id": session_a.user_id, "room_code": code}))
+	assert(not unauthorized.is_exception() and not bool(JSON.parse_string(unauthorized.payload).get("accepted", true)),
+		"Ein Mitspieler ohne Gastgeberrolle darf keine Einladung versenden.")
+	socket_a.close()
+	socket_b.close()
+	var deleted_a = await client_a.rpc_async(session_a, "delete_account", "{}")
+	var deleted_b = await client_b.rpc_async(session_b, "delete_account", "{}")
+	assert(not deleted_a.is_exception() and not deleted_b.is_exception(), "Die Testkonten müssen entfernt werden können.")
+	print("VOID_BASTION_SOCIAL_INTEGRATION_OK")
+	quit()
@@ -0,0 +1,62 @@
+param(
+    [switch]$Apply
+)
+
+$ErrorActionPreference = 'Stop'
+$bundle = (Resolve-Path (Join-Path $PSScriptRoot '..\server\nakama\runtime\build\index.js')).Path
+$test = (Resolve-Path (Join-Path $PSScriptRoot '..\server\nakama\tests\runtime_sim_test.js')).Path
+$remoteFile = '/mnt/user/appdata/void-bastion-online/nakama/modules/build/index.js'
+$remoteHost = 'unraid-codex'
+
+function Assert-LastExit([string]$step) {
+    if ($LASTEXITCODE -ne 0) { throw "$step fehlgeschlagen (Exitcode $LASTEXITCODE)." }
+}
+
+& node $test
+Assert-LastExit 'Nakama-Simulationstest'
+
+$localHash = (Get-FileHash -LiteralPath $bundle -Algorithm SHA256).Hash.ToLowerInvariant()
+$remoteHashLine = & ssh -o BatchMode=yes $remoteHost "sha256sum $remoteFile"
+Assert-LastExit 'Server-Hashprüfung'
+$remoteHash = ($remoteHashLine -split '\s+')[0].ToLowerInvariant()
+
+Write-Output "Lokal:  $localHash"
+Write-Output "Unraid: $remoteHash"
+if ($localHash -eq $remoteHash) {
+    Write-Output 'Nakama ist bereits auf dem aktuellen Stand.'
+    exit 0
+}
+if (-not $Apply) {
+    Write-Output 'Nur geprüft. Zum Veröffentlichen erneut mit -Apply ausführen.'
+    exit 0
+}
+
+$stamp = Get-Date -Format 'yyyyMMdd-HHmmss'
+$upload = "$remoteFile.upload-$stamp"
+$backup = "$remoteFile.pre-$stamp"
+
+& scp -o BatchMode=yes $bundle "${remoteHost}:$upload"
+Assert-LastExit 'Upload'
+$uploadedHashLine = & ssh -o BatchMode=yes $remoteHost "sha256sum $upload"
+Assert-LastExit 'Upload-Hashprüfung'
+if (($uploadedHashLine -split '\s+')[0].ToLowerInvariant() -ne $localHash) {
+    throw 'Upload-Hash stimmt nicht überein. Aktive Serverdatei wurde nicht verändert.'
+}
+
+& ssh -o BatchMode=yes $remoteHost "cp -p $remoteFile $backup && mv $upload $remoteFile && docker restart void-bastion-nakama"
+Assert-LastExit 'Sicherung, Aktivierung oder Neustart'
+
+$healthy = $false
+for ($attempt = 1; $attempt -le 15; $attempt++) {
+    Start-Sleep -Seconds 2
+    $status = & ssh -o BatchMode=yes $remoteHost 'docker inspect -f "{{.State.Health.Status}}" void-bastion-nakama'
+    if ($LASTEXITCODE -eq 0 -and $status.Trim() -eq 'healthy') {
+        $healthy = $true
+        break
+    }
+}
+if (-not $healthy) {
+    throw "Nakama ist nach dem Neustart nicht healthy. Sicherung auf Unraid: $backup. Nicht automatisch zurückgerollt."
+}
+
+Write-Output "Nakama läuft healthy. Wiederherstellbare Sicherung: $backup"
Author	SHA1	Message	Date
Emporex	d53467baf2	Release alpha 10 with bilingual UI and social co-op	2026-10-10 12:50:27 +02:00
Emporex	7d5cad7277	Record manual Netcup website deployment	2026-10-09 23:53:32 +02:00
Emporex	acb7301262	Document direct deployment and add safe Nakama helper	2026-10-09 23:34:42 +02:00
Emporex	9b0eab4273	Fix corrupted Windows export in alpha 8	2026-10-09 15:04:09 +02:00
Emporex	e63e08ddde	Prepare Void Bastion alpha 7 release	2026-10-06 23:59:12 +02:00
Emporex	56077e88a5	Release Void Bastion alpha.5	2026-10-06 18:34:49 +02:00