Upload via GUI (194 Dateien)

CHANGELOG.md

@@ -2,7 +2,86 @@
 
 Alle nennenswerten Änderungen an AeroMC werden hier festgehalten.
 
-## [1.1.6] - 2026-10-02
+## [1.2.1] - 2026-10-05
+
+### Neu
+- Garderobe im Skin-Fenster: Skins (samt Armform) und eigene AeroMC-Umhänge speichern und mit einem Klick wieder anziehen – vor jedem Skinwechsel im Launcher wird der bisherige Skin automatisch gesichert, denn Mojang merkt sich keine alten Skins
+- Erfolge: 17 Erfolge (z. B. Spielzeit, Starts, Instanzen, Mods, Modpack, erster Freund, eigener Umhang, Skin aus dem Editor) mit „Erfolg erzielt!“-Meldung passend zum Design (im Minecraft-Design wie im Spiel); ein Klick auf die Meldung öffnet die Übersicht
+- Freunde mit 3D-Figur: Neben der Freundesliste dreht sich groß die Figur des ausgewählten Freundes mit Skin, 2. Ebene und Umhang (online läuft sie, offline steht sie) – das Freunde-Fenster ist dafür breiter, schmal gezogen steht die Figur über der Liste; die Köpfe in der Liste zeigen ebenfalls die 2. Ebene
+- Leistungs-Paket im Mod-Dialog: installiert mit einem Klick passende Performance-Mods – Sodium (bzw. Embeddium), Lithium (bzw. Radium), FerriteCore, Entity Culling, ImmediatelyFast, ModernFix und Dynamic FPS; Vorhandenes und für die Version nicht Verfügbares wird übersprungen, mit OptiFine bleibt Sodium weg
+- Starten-Knopf mit Fortschritt: füllt sich während Download und Vorbereitung und zeigt die Phase (z. B. „Assets 57 %“), danach kurz „Läuft ✓“
+- Mehr Leben in der Oberfläche (alles über „Bewegte Oberfläche“ abschaltbar):
+  - Laufende Instanzen haben einen pulsierenden Rand – man sieht sofort, was gerade gespielt wird
+  - Instanzen löschen, verschieben oder Gruppen auf-/zuklappen: Karten schrumpfen weg bzw. blenden ein, die übrigen rutschen weich nach
+  - Skin übernommen: Die Figur dreht sich einmal um sich selbst; nach einem Umhang-Wechsel weht der Umhang kurz auf
+  - Konto gewechselt: Der Spielerkopf oben rechts dreht sich wie eine Münze zum neuen Konto
+  - Erfolg erzielt: Funken um die Meldung, im Minecraft-Design grüne XP-Kugeln
+  - Freund kommt online: Sein Kopf hüpft in der Freundesliste, der grüne Punkt pulsiert
+  - AeroMC/Nachtlila: dezent treibende Lichtpunkte im Instanzbereich
+  - Minecraft-Design: Wolken ziehen durch die Werkzeugleiste, und beim Download zeigt das Block-Symbol der Instanz Abbau-Risse als Fortschritt
+  - Das Zahnrad dreht sich beim Darüberfahren, das Block-Symbol einer Instanz kippt leicht zur Maus
+- Armform-Prüfung im Skin-Fenster: Passt die eingestellte Armform nicht zur Skin-Datei (gequetschte Arme oder dunkle Streifen), zeigt AeroMC einen Hinweis und stellt sie mit einem Klick richtig
+- Absturz-Assistent erkennt zu alte Forge-Versionen, die mit aktuellem Java 8 abstürzen („ManifestEntryVerifier“), und aktualisiert Forge auf Wunsch auf die neueste Version für dieselbe Minecraft-Version
+
+### Geändert
+- Statistik-Fenster mit zwei Reitern: „Spielzeit“ und „Erfolge (x/17)“
+- Update-Meldung zeigt die Änderungshinweise formatiert an (Überschriften, Listen, fett/kursiv, Code, Links) statt als rohen Markdown-Text; das Fenster ist dafür größer, Links öffnen im Browser
+- Einstellungen aufgeräumt: jede Option als eigene Zeile mit kurzer Erklärung und Schalter statt Häkchen, alles einspaltig statt verstreuter Kacheln; neu sortiert in Allgemein, Darstellung, Spiel (inkl. Konsole), Java & Erweitert, Freunde & Umhänge (neu), Netzwerk, Konten, Backup (Welt-Sicherung jetzt bei „Automatisch sichern“)
+
+### Behoben
+- Alte Forge-Versionen vor Minecraft 1.13 (z. B. 1.12.2) starteten nicht („Hauptklasse net.minecraft.launchwrapper.Launch konnte nicht gefunden werden“) – Klassenpfad und Startargumente fehlten
+- Bei Forge und NeoForge wurde ohne festgelegte Version teils die älteste statt der neuesten Version gewählt – die Versionsliste ist jetzt richtig sortiert
+- Der Mod-Katalog zeigte bei von Hand kopierten oder importierten Mods „Installieren“, obwohl sie schon da waren – AeroMC erkennt sie jetzt per Prüfsumme über Modrinth
+- Der ZIP-Import (AeroMC-Export oder gezippte MultiMC/Prism-Instanz) blockierte bei großen Archiven den Launcher – die Dateien werden jetzt im Hintergrund verschoben bzw. kopiert
+
+## [1.2.0] - 2026-10-04
+
+### Neu
+- Untergruppen (optional): im Feld „Gruppe“ mit „/“ trennen, z. B. „Modpacks/Survival“ – auch mehrere Ebenen tief. Untergruppen erscheinen eingerückt unter ihrer Gruppe, lassen sich einzeln einklappen und per Drag & Drop befüllen; die Anzahl an einer Gruppe zählt ihre Untergruppen mit
+- Importe aus anderen Launchern zeigen jetzt genauen Fortschritt: Instanz x von y, übertragene GB, Prozent, Tempo, Restzeit und die gerade kopierte Datei
+- Import abbrechen: fertig übernommene Instanzen bleiben erhalten, die gerade halb kopierte wird wieder entfernt
+- Vor dem Kopieren prüft AeroMC, ob genug Speicherplatz frei ist, und nennt sonst benötigte und freie GB
+- Konto-Menü oben rechts (wie in MultiMC): Ein Klick auf den Kontonamen klappt alle Konten mit Spielerkopf auf – das aktive ist markiert, ein Klick wechselt sofort. Dazu „Konto hinzufügen…“, „Skin ändern…“ und „Konten verwalten…“
+
+### Geändert
+- Plugin „AeroMC Freunde“ 1.5.1: merkt sich den von Mojang bestätigten Namen schon bei der Anmeldung und beim Senden einer Anfrage – Spieler sind damit per Name auffindbar, bevor sie zum ersten Mal über AeroMC gespielt haben (Server-Update empfohlen, der Launcher funktioniert auch mit 1.5.0)
+
+### Behoben
+- Freundschaftsanfragen zeigten statt des Namens nur eine lange ID (UUID), wenn der Absender noch nie über AeroMC gespielt hatte – fehlende Namen holt der Launcher jetzt direkt bei Mojang (auch in der Freundesliste und bei gesendeten Anfragen)
+- Große Importe (viele GB, z. B. 60 GB aus MultiMC/Prism, CurseForge, Modrinth App, Minecraft Launcher oder Technic) froren den Launcher komplett ein – kopiert wird jetzt im Hintergrund, der Launcher bleibt bedienbar
+- Einzelne gesperrte Dateien (z. B. eine gerade geöffnete Welt) brechen den Import nicht mehr ab, sie werden übersprungen und gemeldet
+- „Instanz kopieren“, „Löschen“ und das Ersetzen einer vorhandenen Instanz beim erneuten Import blockierten bei großen Instanzen den Launcher – das läuft jetzt im Hintergrund
+- Der Spielerkopf oben neben dem Kontonamen und in der Kontoliste zeigte die 2. Skin-Ebene (Mütze, Haare, Kragen, Ärmel) nicht sichtbar – er wird jetzt selbst in 3D gezeichnet, die 2. Ebene steht wie im Spiel plastisch ab
+
+## [1.1.9] - 2026-10-04
+
+### Neu
+- Startanimation: Beim Öffnen dreht sich das AeroMC-Logo mit Schriftzug, danach baut sich der Launcher von der Mitte nach außen auf – Schriftzug passend zum Design (Minecraft mit Pixel-Schrift), nicht beim Start im Infobereich
+- Lebendige Skin-Figur im Hintergrund: atmet, wiegt sich leicht, der Umhang schwingt, und der Kopf folgt dem Mauszeiger – pausiert, solange der Launcher minimiert oder im Hintergrund ist
+- Fenster wie Optionen, Mods, Skin und Freunde wachsen beim Öffnen aus dem angeklickten Knopf heraus
+- Instanzen blenden beim Öffnen des Launchers nacheinander ein; beim Darüberfahren hebt sich das Block-Symbol und dreht sich ein Stück
+- Designwechsel blenden weich über statt hart umzuschalten
+- Optionen → Darstellung → Animationen: „Startanimation“ und „Bewegte Oberfläche“ einzeln abschaltbar; ist in Windows „Animationen anzeigen“ aus, bleibt die Oberfläche ruhig
+
+## [1.1.8] - 2026-10-04
+
+### Behoben
+- Das Skin-Fenster und „Aktuellen Skin laden“ im Skin-Editor zeigten bei manchen Konten einen Standard-Skin (z. B. Efe) statt des eigenen Skins – angezeigt wird jetzt der Skin, den andere Spieler im Spiel sehen; direkt nach einer eigenen Skin-Änderung noch kurz der neue Stand aus dem Konto, bis Mojang ihn überall verteilt hat
+
+## [1.1.7] - 2026-10-03
+
+### Neu
+- Umhänge im Skin-Fenster: offiziellen Mojang-Umhang auswählen oder ablegen (Liste zeigt alle Umhänge, die das Konto besitzt) und den eigenen AeroMC-Umhang verwalten – Figur und Skin-Hintergrund zeigen den Umhang mit
+- Skin-Editor, neuer Modus „Umhang“: eigene Umhänge gestalten, auch in HD bis 1024×512 – mit allen Werkzeugen, Pinselgröße, Spiegeln (linke ↔ rechte Kante), Zoom und Verschieben, Rückgängig auch über Größenwechsel
+- Umhang auf der 3D-Figur bemalen, wahlweise als Elytra ansehen, beliebiges Bild (PNG, JPG …) mit „Bild einsetzen…“ auf die Außenseite setzen, aktuellen Umhang laden, als PNG speichern oder mit „Als Umhang übernehmen“ hochladen
+- AeroMC-Umhänge im Spiel: in jeder Minecraft-Version und mit jedem Loader (Vanilla, Fabric, Quilt, Forge, NeoForge) ohne zusätzliche Mod sichtbar – für einen selbst und für andere AeroMC-Spieler; abschaltbar unter Optionen → Spiel → Umhänge
+- Mod „AeroMC Umhänge“ für Fabric und Quilt: damit sehen auch Spieler mit anderen Launchern (offizieller Launcher, MultiMC, Prism, Modrinth App …) die AeroMC-Umhänge – ein Jar für Minecraft 1.14 bis 26.x, nur auf dem Client nötig
+
+### Geändert
+- Suche in der Werkzeugleiste: statt des dauerhaft sichtbaren Suchfelds gibt es eine Lupe – ein Klick oder Strg+F klappt das Feld auf, Esc leert und schließt es, mit Suchbegriff bleibt es offen
+- Benötigt für eigene Umhänge das Plugin „AeroMC Freunde“ 1.5.0 auf dem Server
+
+## [1.1.6] - 2026-10-03
 
 ### Neu
 - Skin-Editor: Skins direkt im Launcher pixeln – erreichbar im Skin-Fenster über „Im Editor bearbeiten…“
@@ -15,11 +94,14 @@ Alle nennenswerten Änderungen an AeroMC werden hier festgehalten.
 - Aktuellen Skin laden, PNG öffnen oder speichern und das Ergebnis mit einem Klick als Skin übernehmen – klassische und schmale Arme, alte 64×32-Skins werden automatisch umgewandelt
 - Skin-Hintergrund: Armform wählbar (Optionen → Darstellung) – „Automatisch“ übernimmt die Armform des Kontos, alternativ fest „Normal“ oder „Schmal“
 - Designs zur Auswahl (Optionen → Darstellung → Design, mit Vorschau-Kacheln): „Klassisch“ hell oder dunkel wie bisher, „AeroMC“ im Look der Webseite (Nachtblau, Cyan-Verläufe, runde Knöpfe), „Nachtlila“ (wie AeroMC, nur in dunklem Lila) und „Minecraft“ mit Block-Optik, Stein-Knöpfen, grünem Starten-Knopf und eigener Pixel-Schrift
-- Ein gewähltes Design gilt sofort in allen offenen Fenstern
+- Ein Klick auf eine Kachel zeigt das Design sofort zur Probe, nach dem Speichern gilt es in allen offenen Fenstern
 - Eigene Titelleiste im Design statt der weißen Windows-Leiste – Minimieren, Maximieren und Schließen bleiben echte Windows-Knöpfe (Andocken, Fensterlayouts) und werden passend eingefärbt
 - Import aus der Modrinth App (Importieren → „Modrinth App“, auch im Installer): übernimmt Name, Gruppe, Symbol, Minecraft-Version, Loader, Arbeitsspeicher, Java-Einstellungen, Spielzeit sowie Mods, Welten und Einstellungen – auch bei verlegtem Datenordner und während die Modrinth App läuft
 - Aus der Modrinth App übernommene Modrinth-Modpacks bleiben mit ihrem Paket verknüpft und lassen sich in AeroMC aktualisieren
 
+### Geändert
+- Die Design-Auswahl (bisher „Design: Dunkel/Hell“ unter Optionen → Allgemein) steht jetzt unter Optionen → Darstellung
+
 ### Behoben
 - Das Symbol für „Optionen“ sah aus wie eine Sonne – jetzt ein Zahnrad
 - Der Skin-Hintergrund zeigte schmale (Alex-)Skins mit breiten Armen – dadurch erschienen falsche Streifen an den Armen

README.md

@@ -6,7 +6,7 @@
 
 Ein Minecraft-Launcher für Windows mit getrennten Instanzen, Mod-Unterstützung, Spielaufzeichnung, Freundesystem und Microsoft-Anmeldung.
 
-Aktueller Stand: Version 1.1.6
+Aktueller Stand: Version 1.2.0
 
 <img src="docs/aeromc.png" alt="AeroMC – Instanzliste mit Seitenleiste und Skin-Vorschau" width="820" />
 
@@ -62,9 +62,13 @@ Der Launcher konzentriert sich auf den Alltag: Instanz anlegen, Konto auswählen
 - Eigener Server auf Wunsch verborgen, Freundesystem komplett abschaltbar
 
 **Konten, Welten und Backups**
-- Microsoft-Login mit mehreren Konten
+- Microsoft-Login mit mehreren Konten – Wechsel mit einem Klick über das Konto-Menü oben rechts
 - Eigenen Skin im Launcher hochladen, mit Live-Vorschau anpassen (klassisch/schlank) und zurücksetzen
 - **Skin-Editor mit zwei Schichten**: Skins selbst pixeln – auf der Vorlage oder direkt auf der 3D-Figur, mit Spiegeln, Füllen, Pipette und Rückgängig
+- **Eigene Umhänge, auch HD bis 1024×512**: im Skin-Editor gestalten, im Spiel in jeder Version und mit jedem Loader sichtbar – für Spieler mit anderen Launchern gibt es den Mod „AeroMC Umhänge“
+- Offiziellen Mojang-Umhang direkt im Launcher wechseln oder ablegen
+- **Garderobe**: Skins und Umhänge speichern und mit einem Klick wieder anziehen – der bisherige Skin wird vor jedem Wechsel automatisch gesichert
+- Armform-Prüfung: Hinweis und Ein-Klick-Korrektur, wenn die Armform nicht zur Skin-Datei passt
 - Skin-Hintergrund des aktiven Kontos (mehrere Posen, passende Armform, einstellbare Deckkraft, optional wechselnd)
 - Welten, Ressourcenpakete, Datenpakete, Screenshots, Serverliste und Logdateien verwalten
 - Serverliste mit Live-Status und Desktop-Verknüpfung pro Server (startet die Instanz und verbindet direkt)
@@ -130,7 +134,7 @@ Automatische Updates bleiben getrennt: Setup erhält nur Setup-Updates, Portable
 
 Jede Instanz hat:
 
-- Namen und optionale Gruppe
+- Namen und optionale Gruppe – Untergruppen mit „/“ trennen, z. B. `Modpacks/Survival` (eingerückt, einzeln einklappbar, per Drag & Drop befüllbar)
 - Minecraft-Version und optionalen Mod-Loader
 - optionales Icon (vorgegeben, aus Minecraft extrahiert oder eigenes Bild) und Notizen
 - eigene Mods, Ressourcenpakete, Shader, Welten, Datenpakete, Screenshots, Aufzeichnungen und Serverliste
@@ -162,7 +166,7 @@ Im Launcher:
 
 | Taste | Wirkung |
 |---|---|
-| Strg+F | Suche fokussieren |
+| Strg+F | Suche öffnen (Lupe in der Werkzeugleiste), Esc leert und schließt sie |
 | Strg+N | Neue Instanz anlegen |
 | Strg+1 … Strg+5 | Schnellstart-Instanz starten |
 | Entf | Markierte Instanz(en) löschen |
@@ -195,6 +199,8 @@ Im Spiel (solange ein über AeroMC gestartetes Minecraft läuft):
 
 Existiert bereits eine Instanz mit demselben Namen, wird sie ersetzt.
 
+**Große Importe:** Auch viele Gigabyte werden im Hintergrund kopiert – der Launcher bleibt bedienbar. Vorher prüft AeroMC, ob genug Speicherplatz frei ist. Oben im Import-Fenster stehen Instanz, übertragene GB, Prozent, Tempo, Restzeit und die aktuelle Datei; **Abbrechen** behält fertig übernommene Instanzen und entfernt die halb kopierte. Einzelne gesperrte Dateien werden übersprungen und gemeldet.
+
 Beim offiziellen Minecraft Launcher werden nur benutzerdefinierte Profile angeboten (keine „Latest Release“/„Latest Snapshot“). Bei gemeinsamen Standard-Spielordnern übernimmt AeroMC spielrelevante Daten (Mods, Welten, Konfiguration), nicht den kompletten Cache.
 
 **Modrinth App:** Übernommen werden Name, Gruppe, Symbol, Minecraft-Version, Loader, Arbeitsspeicher, Java-Einstellungen, Spielzeit sowie Mods, Welten und Einstellungen. Modrinth-Modpacks bleiben mit ihrem Paket verknüpft und lassen sich weiter aktualisieren. Ein in der App verlegter Datenordner wird automatisch gefunden, und die Modrinth App darf dabei geöffnet bleiben – AeroMC liest auch ihr Schreibprotokoll mit. An den Daten der Modrinth App wird nichts verändert.
@@ -279,6 +285,33 @@ Die Änderung wird direkt bei Mojang für das angemeldete Konto hinterlegt und g
 | M | Spiegeln ein/aus |
 | L | Schicht wechseln |
 | Strg+Z / Strg+Y | Rückgängig / Wiederholen |
+| 0 | Umhang: Ansicht einpassen |
+
+### Umhänge
+
+Im Skin-Fenster (**Kontoname oben rechts → Skin ändern…**) gibt es den Bereich **Umhang**:
+
+- **Offizieller Umhang:** zeigt alle Umhänge, die dein Konto bei Mojang besitzt (z. B. Migrator, Pan …) – auswählen oder „Kein Umhang“. Das gilt wie der Skin überall, auch außerhalb von AeroMC.
+- **AeroMC-Umhang:** dein eigener Umhang, auch in HD. **Gestalten…** öffnet den Skin-Editor im Modus **Umhang**, **Entfernen** löscht ihn wieder.
+
+Im Editor-Modus **Umhang**:
+
+- Größe wählen: Normal (64×32) oder HD 128×64, 256×128, 512×256, 1024×512
+- Alle Werkzeuge wie beim Skin, dazu Pinselgröße (1–16 Pixel); Spiegeln malt linke und rechte Kante gleichzeitig
+- Mausrad zoomt, rechte oder mittlere Maustaste verschiebt die Ansicht, **0** passt sie wieder ein
+- In der 3D-Ansicht direkt auf dem Umhang an der Figur malen; **Als Elytra zeigen** zeigt dieselbe Datei als Flügel
+- **Bild einsetzen…** setzt ein beliebiges Bild (PNG, JPG …) auf die Außenseite
+- **Aktuellen Umhang laden**, PNG öffnen oder speichern, **Als Umhang übernehmen** lädt ihn hoch
+
+**Wer sieht den AeroMC-Umhang?**
+
+| Spieler | sieht den AeroMC-Umhang? |
+|---|---|
+| Spielt über AeroMC (Optionen → Spiel → Umhänge eingeschaltet) | Ja – in jeder Minecraft-Version und mit jedem Loader, ohne Mod |
+| Anderer Launcher mit Fabric oder Quilt und dem Mod **„AeroMC Umhänge“** | Ja – ein Jar für Minecraft 1.14 bis 26.x, nur auf dem Client nötig |
+| Anderer Launcher ohne den Mod (auch mit OptiFine) | Nein – sieht weiter den offiziellen Mojang-Umhang |
+
+Der AeroMC-Umhang hat Vorrang vor dem offiziellen Umhang. Benötigt das Plugin „AeroMC Freunde“ 1.5.0 auf dem Server.
 
 ## Backup und Wiederherstellung
 
@@ -308,10 +341,15 @@ Speicherort: `Dokumente\AeroMC Launcher\Backups`.
 ### Darstellung
 - Design: Klassisch Dunkel, Klassisch Hell, AeroMC, Nachtlila oder Minecraft – mit Vorschau-Kacheln, gilt nach dem Speichern in allen Fenstern
 - Block-Symbole räumlich (3D)
+- Animationen:
+  - **Startanimation**: Beim Öffnen dreht sich das AeroMC-Logo, danach baut sich das Fenster von der Mitte aus auf (nicht beim Start im Infobereich)
+  - **Bewegte Oberfläche**: Die Skin-Figur im Hintergrund atmet und schaut dem Mauszeiger nach, Fenster wachsen aus dem angeklickten Knopf, Instanzen blenden beim Öffnen ein und heben sich beim Darüberfahren, Designs blenden weich über
+  - Beides einzeln abschaltbar; ist in Windows „Animationen anzeigen“ aus, bleibt die Oberfläche ruhig
 - Skin-Hintergrund: Quelle, Pose, Armform (automatisch vom Konto, normal oder schmal), Deckkraft, optional automatischer Wechsel zwischen mehreren Konten
 
 ### Spiel
 - Standard-RAM (min./max.)
+- Umhänge: AeroMC-Umhänge im Spiel anzeigen (gilt ab dem nächsten Start)
 - Fenstergröße bzw. maximiert starten
 - Mods: vor jedem Start automatisch nach Updates suchen und installieren
 

agent/src/de/aeromc/capes/Agent.java

@@ -0,0 +1,76 @@
+package de.aeromc.capes;
+
+import java.lang.instrument.Instrumentation;
+
+/**
+ * AeroMC-Agent.
+ *
+ * Wird vom Launcher per -javaagent an Minecraft angehängt (jede Version, jeder
+ * Loader) und kann zwei Dinge, einzeln zuschaltbar:
+ *
+ *   Umhänge:    klinkt sich in Mojangs authlib ein – über sie lädt Minecraft für
+ *               jeden Spieler Skin und Umhang – und setzt dort den AeroMC-Umhang
+ *               des Spielers ein, falls er einen hat. Alles Weitere (Herunterladen,
+ *               Zwischenspeichern, Anzeigen, auch HD) erledigt Minecraft selbst.
+ *   Spieldesign: AeroMC-Ladebildschirm, Fenstertitel und -symbol (siehe Design).
+ *
+ * Argument, Teile durch "|" getrennt:
+ *   <Basisadresse des Umhang-Servers>   (…/wp-json/aeromc/v1)
+ *   capes=0                              Umhänge aus
+ *   design=<Ordner>                      Spieldesign an, Grafiken aus diesem Ordner
+ * Ein Argument nur mit Adresse (ältere Launcher) heißt: nur Umhänge.
+ */
+public final class Agent {
+    /** Unter diesem Schlüssel liegt der Nachschlage-Dienst in den System-Properties. */
+    public static final String SCHLUESSEL = "aeromc.capes.hook";
+
+    private Agent() {}
+
+    public static void premain(String argument, Instrumentation inst) {
+        starte(argument, inst);
+    }
+
+    public static void agentmain(String argument, Instrumentation inst) {
+        starte(argument, inst);
+    }
+
+    private static void starte(String argument, Instrumentation inst) {
+        String basis = Nachschlagen.STANDARD_BASIS;
+        boolean umhaenge = true;
+        String design = null;
+        String mods = null;
+        if (argument != null) {
+            for (String teil : argument.split("\\|")) {
+                if (teil.startsWith("http")) basis = teil;
+                else if (teil.equals("capes=0")) umhaenge = false;
+                else if (teil.startsWith("design=") && teil.length() > 7) design = teil.substring(7);
+                else if (teil.startsWith("mods=") && teil.length() > 5) mods = teil.substring(5);
+            }
+        }
+        if (mods != null) {
+            try {
+                Design.installiereMods(mods, inst);
+            } catch (Throwable t) {
+                System.out.println("[AeroMC] Mod-Schalter konnte nicht starten: " + t);
+            }
+        }
+        if (umhaenge) {
+            try {
+                // Die eingefügten Befehle in authlib holen sich den Dienst von hier – nur
+                // über JDK-Typen, damit es mit jedem Classloader und Modulsystem klappt.
+                System.getProperties().put(SCHLUESSEL, new Nachschlagen(basis));
+                inst.addTransformer(new Umbau());
+                System.out.println("[AeroMC] Umhang-Agent aktiv");
+            } catch (Throwable t) {
+                System.out.println("[AeroMC] Umhang-Agent konnte nicht starten: " + t);
+            }
+        }
+        if (design != null) {
+            try {
+                Design.installiere(design, inst);
+            } catch (Throwable t) {
+                System.out.println("[AeroMC] Spieldesign konnte nicht starten: " + t);
+            }
+        }
+    }
+}

agent/src/de/aeromc/capes/Design.java

@@ -0,0 +1,141 @@
+package de.aeromc.capes;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.lang.instrument.Instrumentation;
+import java.lang.reflect.Method;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+import java.util.function.Function;
+
+/**
+ * AeroMC-Look im Spiel (Minecraft 1.14 … 26.x):
+ *
+ *   – Ladebildschirm: AeroMC-Nachtblau statt Mojang-Rot, hellblauer Balken und
+ *     AeroMC-Logo statt Mojang-Logo. Das Logo lädt Minecraft am Ressourcenpaket
+ *     vorbei direkt aus dem Spiel – deshalb tauscht der Agent den Datenstrom aus.
+ *   – Fenster: Titel "AeroMC - Minecraft …" und AeroMC-Symbol.
+ *
+ * Titel-Logo, Untertitel, Sprüche und Knöpfe kommen über ein Ressourcenpaket,
+ * das der Launcher anlegt (src/spieldesign.js).
+ *
+ * Die umgebauten Stellen im Spiel holen sich ihre Helfer – wie beim Umhang –
+ * über die System-Properties und nur über JDK-Typen (java.util.function.Function),
+ * damit es mit jedem Classloader klappt (Vanilla, Fabric, Forge, NeoForge).
+ */
+final class Design {
+    static final String LOGO = "aeromc.design.logo";
+    static final String LOGO_ALT = "aeromc.design.logoAlt";
+    static final String TITEL = "aeromc.design.titel";
+    static final String ICON = "aeromc.design.icon";
+    static final String MODS = "aeromc.mods";
+
+    /** Hintergrund des Ladebildschirms (wie das AeroMC-Design im Launcher). */
+    static final int HINTERGRUND = 0x0A0E1A;
+    /** Fortschrittsbalken. */
+    static final int BALKEN = 0x4FD2FF;
+    /** Breite des Balkens als Anteil der Bildschirmbreite (das Logo ist jetzt bildschirmbreit). */
+    static final float BALKEN_ANTEIL = 0.56f;
+
+    private static final int[] ICON_GROESSEN = {16, 32, 48, 64, 128, 256};
+    /** Pixelspeicher der Symbole festhalten, bis GLFW sie übernommen hat. */
+    private static final List<ByteBuffer> FESTHALTEN = new ArrayList<>();
+
+    private Design() {}
+
+    static void installiere(String ordner, Instrumentation inst) {
+        File dir = new File(ordner);
+        Properties p = System.getProperties();
+        p.put(LOGO, strom(new File(dir, "ladelogo.png")));
+        p.put(LOGO_ALT, strom(new File(dir, "ladelogo_alt.png")));
+        p.put(TITEL, (Function<Object, Object>) Design::titel);
+        p.put(ICON, (Function<Object, Object>) bilder -> symbol(dir, bilder));
+        inst.addTransformer(new DesignUmbau());
+        System.out.println("[AeroMC] Spieldesign aktiv");
+    }
+
+    /**
+     * Mod-Schalter: Klick auf „Mods verwalten“ im Pausemenü (Adresse aeromc://mods)
+     * meldet sich beim Launcher, der dann das Mod-Fenster über dem Spiel öffnet.
+     * Rückgabe TRUE = erledigt (Minecraft öffnet keinen Link), sonst FALSE.
+     */
+    static void installiereMods(String adresse, Instrumentation inst) {
+        System.getProperties().put(MODS, (Function<Object, Object>) link -> {
+            if (link == null || !link.toString().startsWith("aeromc:")) return Boolean.FALSE;
+            Thread t = new Thread(() -> {
+                try {
+                    java.net.HttpURLConnection c = (java.net.HttpURLConnection) new java.net.URL(adresse).openConnection();
+                    c.setConnectTimeout(2000);
+                    c.setReadTimeout(4000);
+                    c.getResponseCode();
+                    c.disconnect();
+                } catch (Throwable e) {
+                    System.out.println("[AeroMC] Launcher fuer den Mod-Schalter nicht erreichbar: " + e);
+                }
+            }, "AeroMC-Mod-Schalter");
+            t.setDaemon(true);
+            t.start();
+            return Boolean.TRUE;
+        });
+        inst.addTransformer(new ModsUmbau());
+        System.out.println("[AeroMC] Mod-Schalter aktiv");
+    }
+
+    /** Ersetzt den Datenstrom des Mojang-Logos durch das AeroMC-Logo (bei Fehlern bleibt das Original). */
+    private static Function<Object, Object> strom(File datei) {
+        return original -> {
+            try {
+                return new ByteArrayInputStream(Files.readAllBytes(datei.toPath()));
+            } catch (Throwable t) {
+                System.out.println("[AeroMC] Ladelogo nicht lesbar: " + t);
+                return original;
+            }
+        };
+    }
+
+    private static Object titel(Object original) {
+        if (original == null) return null;
+        String s = original.toString();
+        return s.startsWith("AeroMC") ? original : "AeroMC - " + s;
+    }
+
+    /**
+     * Baut aus den mitgelieferten Rohdaten (icon_N.rgba) einen neuen
+     * GLFWImage.Buffer. LWJGL wird über den Classloader des übergebenen Buffers
+     * angesprochen – der Agent selbst kennt LWJGL nicht.
+     */
+    private static Object symbol(File dir, Object original) {
+        if (original == null) return null;
+        try {
+            List<int[]> groessen = new ArrayList<>();
+            List<byte[]> daten = new ArrayList<>();
+            for (int n : ICON_GROESSEN) {
+                File f = new File(dir, "icon_" + n + ".rgba");
+                if (!f.isFile()) continue;
+                byte[] b = Files.readAllBytes(f.toPath());
+                if (b.length != n * n * 4) continue;
+                groessen.add(new int[] {n, n});
+                daten.add(b);
+            }
+            if (daten.isEmpty()) return original;
+            ClassLoader cl = original.getClass().getClassLoader();
+            Class<?> bild = Class.forName("org.lwjgl.glfw.GLFWImage", true, cl);
+            Object puffer = bild.getMethod("malloc", int.class).invoke(null, daten.size());
+            Method hole = puffer.getClass().getMethod("get", int.class);
+            Method setze = bild.getMethod("set", int.class, int.class, ByteBuffer.class);
+            for (int i = 0; i < daten.size(); i++) {
+                ByteBuffer px = ByteBuffer.allocateDirect(daten.get(i).length);
+                px.put(daten.get(i)).flip();
+                synchronized (FESTHALTEN) { FESTHALTEN.add(px); }
+                setze.invoke(hole.invoke(puffer, i), groessen.get(i)[0], groessen.get(i)[1], px);
+            }
+            return puffer;
+        } catch (Throwable t) {
+            System.out.println("[AeroMC] Fenstersymbol nicht gesetzt: " + t);
+            return original;
+        }
+    }
+}

agent/src/de/aeromc/capes/DesignUmbau.java

@@ -0,0 +1,352 @@
+package de.aeromc.capes;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.nio.charset.StandardCharsets;
+import java.security.ProtectionDomain;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.InsnNode;
+import org.objectweb.asm.tree.IntInsnNode;
+import org.objectweb.asm.tree.LdcInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.TypeInsnNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+/**
+ * Baut beim Laden um (siehe Design):
+ *
+ *  1. Ladebildschirm – erkannt am Text "textures/gui/title/mojangstudios.png"
+ *     (ab 1.16) bzw. "…/mojang.png" (1.14/1.15), denn die Klassennamen sind je
+ *     Version und Loader anders (verschleiert, Intermediary, SRG, Mojang-Namen):
+ *       ab 1.16:   color(255, 239, 50, 61)      -> AeroMC-Nachtblau
+ *                  color(alpha, 255, 255, 255)  -> Balkenfarbe
+ *       1.14/1.15: weiße Füllung (0xFFFFFF / -1) -> Nachtblau,
+ *                  Balken-Rot (226, 40, 55)     -> Balkenfarbe
+ *  2. Logo-Textur – die innere Klasse des Ladebildschirms ("…$…") liest das
+ *     Logo mit NativeImage.read(InputStream); davor wird der Strom getauscht.
+ *  3. LWJGL-GLFW – Fenstertitel (glfwCreateWindow/glfwSetWindowTitle) und
+ *     Fenstersymbol (glfwSetWindowIcon).
+ *
+ * Eingefügt bzw. ersetzt wird nur geradliniger Code ohne Sprünge mit gleicher
+ * Stapelwirkung – die vorhandenen Stack-Map-Frames bleiben gültig.
+ */
+final class DesignUmbau implements ClassFileTransformer {
+    private static final byte[] MERKMAL = "textures/gui/title/mojang".getBytes(StandardCharsets.UTF_8);
+    private static final String LOGO_NEU = "textures/gui/title/mojangstudios.png";
+    private static final String LOGO_ALT = "textures/gui/title/mojang.png";
+    private static final byte[] TITEL_MERKMAL = "textures/gui/title/minecraft.png".getBytes(StandardCharsets.UTF_8);
+    private static final int KEIN_WERT = Integer.MIN_VALUE;
+
+    /** Name der Ladebildschirm-Klasse, sobald sie gesehen wurde. */
+    private volatile String ladeKlasse;
+    private volatile boolean ladeAlt;
+
+    @Override
+    public byte[] transform(ClassLoader loader, String name, Class<?> umdefiniert, ProtectionDomain pd, byte[] klasse) {
+        if (name == null || umdefiniert != null) return null;
+        try {
+            if ("org/lwjgl/glfw/GLFW".equals(name)) return glfw(klasse);
+            if (name.startsWith("java/") || name.startsWith("jdk/") || name.startsWith("sun/")
+                || name.startsWith("de/aeromc/") || name.startsWith("org/lwjgl/")) return null;
+            String lk = ladeKlasse;
+            if (lk != null && name.startsWith(lk + "$")) return logoStrom(klasse, ladeAlt);
+            if (enthaelt(klasse, MERKMAL)) return ladeBildschirm(name, klasse);
+            if (enthaelt(klasse, TITEL_MERKMAL)) return titelLogo(name, klasse);
+        } catch (Throwable t) {
+            System.out.println("[AeroMC] Spieldesign: " + name + " nicht angepasst: " + t);
+        }
+        return null;
+    }
+
+    // ---------- 1. Ladebildschirm ----------
+
+    private byte[] ladeBildschirm(String name, byte[] klasse) {
+        ClassNode cn = lies(klasse);
+        boolean neu = hatText(cn, LOGO_NEU), alt = hatText(cn, LOGO_ALT);
+        if (!neu && !alt) return null;
+        ladeKlasse = name;
+        ladeAlt = alt && !neu;
+        int r = Design.HINTERGRUND >> 16 & 255, g = Design.HINTERGRUND >> 8 & 255, b = Design.HINTERGRUND & 255;
+        int br = Design.BALKEN >> 16 & 255, bg = Design.BALKEN >> 8 & 255, bb = Design.BALKEN & 255;
+        int hintergrund = 0, balken = 0, vollbild = 0, balkenBreite = 0;
+        for (MethodNode m : cn.methods) {
+            List<AbstractInsnNode> a = befehle(m);
+            for (int i = 0; i < a.size(); i++) {
+                if (!ladeAlt) {
+                    // color(255, 239, 50, 61) – Mojang-Rot
+                    if (i + 4 < a.size() && wert(a.get(i)) == 255 && wert(a.get(i + 1)) == 239
+                        && wert(a.get(i + 2)) == 50 && wert(a.get(i + 3)) == 61 && aufruf(a.get(i + 4), "(IIII)I")) {
+                        setze(m, a, i + 1, r); setze(m, a, i + 2, g); setze(m, a, i + 3, b);
+                        hintergrund++;
+                    }
+                    // color(alpha, 255, 255, 255) – weißer Balken
+                    if (i + 4 < a.size() && a.get(i).getOpcode() == Opcodes.ILOAD && wert(a.get(i + 1)) == 255
+                        && wert(a.get(i + 2)) == 255 && wert(a.get(i + 3)) == 255 && aufruf(a.get(i + 4), "(IIII)I")) {
+                        setze(m, a, i + 1, br); setze(m, a, i + 2, bg); setze(m, a, i + 3, bb);
+                        balken++;
+                    }
+                    // Logo-Fläche auf Vollbild: Höhe = min(Breite·0,75; Höhe)·0,25 und Breite = 4·Höhe
+                    // wird zu Höhe = min(Breite·9/16; Höhe) und Breite = 16/9·Höhe (Bild im 16:9-Format)
+                    AbstractInsnNode n = a.get(i);
+                    if (n instanceof LdcInsnNode && ((LdcInsnNode) n).cst instanceof Double) {
+                        double d = (Double) ((LdcInsnNode) n).cst;
+                        double ersatzWert = d == 0.75 ? 9.0 / 16.0 : d == 0.25 ? 1.0 : d == 4.0 ? 16.0 / 9.0 : -1;
+                        if (ersatzWert > 0) {
+                            LdcInsnNode e = new LdcInsnNode(ersatzWert);
+                            m.instructions.set(n, e);
+                            a.set(i, e);
+                            vollbild++;
+                        }
+                    }
+                    // Fortschrittsbalken: Minecraft macht ihn so breit wie das Logo – jetzt also
+                    // bildschirmbreit; beim Aufruf auf einen Teil der Breite in der Mitte kürzen
+                    if (n instanceof MethodInsnNode && ((MethodInsnNode) n).owner.equals(name)
+                        && ((MethodInsnNode) n).desc.endsWith("IIIIF)V")) {
+                        m.instructions.insertBefore(n, balkenKuerzen(m));
+                        balkenBreite++;
+                    }
+                } else {
+                    AbstractInsnNode n = a.get(i);
+                    // weiße Füllung beim Ein-/Ausblenden: 0xFFFFFF | alpha << 24
+                    if (n instanceof LdcInsnNode && Integer.valueOf(0xFFFFFF).equals(((LdcInsnNode) n).cst)) {
+                        m.instructions.set(n, ersatz(Design.HINTERGRUND, a, i));
+                        hintergrund++;
+                    }
+                    // fill(0, 0, breite, hoehe, -1) – weißer Hintergrund
+                    if (i + 5 < a.size() && n.getOpcode() == Opcodes.ICONST_0 && a.get(i + 1).getOpcode() == Opcodes.ICONST_0
+                        && a.get(i + 2).getOpcode() == Opcodes.ILOAD && a.get(i + 3).getOpcode() == Opcodes.ILOAD
+                        && a.get(i + 4).getOpcode() == Opcodes.ICONST_M1 && aufruf(a.get(i + 5), "(IIIII)V")) {
+                        m.instructions.set(a.get(i + 4), ersatz(0xFF000000 | Design.HINTERGRUND, a, i + 4));
+                        hintergrund++;
+                    }
+                    // Balken-Rot (226, 40, 55) als Gleitkommazahlen
+                    if (n instanceof LdcInsnNode && ((LdcInsnNode) n).cst instanceof Float) {
+                        float f = (Float) ((LdcInsnNode) n).cst;
+                        float neuWert = f == 226f ? br : f == 40f ? bg : f == 55f ? bb : -1f;
+                        if (neuWert >= 0) {
+                            LdcInsnNode e = new LdcInsnNode(neuWert);
+                            m.instructions.set(n, e);
+                            a.set(i, e);
+                            balken++;
+                        }
+                    }
+                }
+            }
+        }
+        System.out.println("[AeroMC] Ladebildschirm angepasst (" + (ladeAlt ? "1.14/1.15" : "ab 1.16")
+            + ", Hintergrund " + hintergrund + ", Balken " + balken + ", Vollbild " + vollbild + ", Balkenbreite " + balkenBreite + ")");
+        return schreibe(cn);
+    }
+
+    /**
+     * Vor dem Aufruf drawProgressBar(…, x1, y1, x2, y2, f): die vier Zahlen und f in
+     * neue lokale Variablen legen, x1/x2 um die Mitte auf BALKEN_ANTEIL der Breite
+     * zusammenziehen und alles wieder auf den Stapel legen.
+     */
+    private static InsnList balkenKuerzen(MethodNode m) {
+        int b = m.maxLocals;
+        m.maxLocals += 7;
+        int x1 = b, y1 = b + 1, x2 = b + 2, y2 = b + 3, f = b + 4, mitte = b + 5, halb = b + 6;
+        InsnList l = new InsnList();
+        l.add(new VarInsnNode(Opcodes.FSTORE, f));
+        l.add(new VarInsnNode(Opcodes.ISTORE, y2));
+        l.add(new VarInsnNode(Opcodes.ISTORE, x2));
+        l.add(new VarInsnNode(Opcodes.ISTORE, y1));
+        l.add(new VarInsnNode(Opcodes.ISTORE, x1));
+        // mitte = (x1 + x2) / 2
+        l.add(new VarInsnNode(Opcodes.ILOAD, x1));
+        l.add(new VarInsnNode(Opcodes.ILOAD, x2));
+        l.add(new InsnNode(Opcodes.IADD));
+        l.add(new InsnNode(Opcodes.ICONST_2));
+        l.add(new InsnNode(Opcodes.IDIV));
+        l.add(new VarInsnNode(Opcodes.ISTORE, mitte));
+        // halb = (int) ((x2 - x1) * anteil / 2)
+        l.add(new VarInsnNode(Opcodes.ILOAD, x2));
+        l.add(new VarInsnNode(Opcodes.ILOAD, x1));
+        l.add(new InsnNode(Opcodes.ISUB));
+        l.add(new InsnNode(Opcodes.I2F));
+        l.add(new LdcInsnNode(Design.BALKEN_ANTEIL / 2f));
+        l.add(new InsnNode(Opcodes.FMUL));
+        l.add(new InsnNode(Opcodes.F2I));
+        l.add(new VarInsnNode(Opcodes.ISTORE, halb));
+        // (mitte - halb, y1, mitte + halb, y2, f)
+        l.add(new VarInsnNode(Opcodes.ILOAD, mitte));
+        l.add(new VarInsnNode(Opcodes.ILOAD, halb));
+        l.add(new InsnNode(Opcodes.ISUB));
+        l.add(new VarInsnNode(Opcodes.ILOAD, y1));
+        l.add(new VarInsnNode(Opcodes.ILOAD, mitte));
+        l.add(new VarInsnNode(Opcodes.ILOAD, halb));
+        l.add(new InsnNode(Opcodes.IADD));
+        l.add(new VarInsnNode(Opcodes.ILOAD, y2));
+        l.add(new VarInsnNode(Opcodes.FLOAD, f));
+        return l;
+    }
+
+    // ---------- 1b. Titel-Logo im Hauptmenü ----------
+    // Minecraft zeichnet vom Logo nur einen 44 Punkte hohen Streifen – zu knapp für
+    // Pyramide, großen Schriftzug und Untertitel. Hier wird er auf 64 Punkte erweitert:
+    //   bis 1.19.4: blit(u 0, v 0, 155, 44) + blit(u 0, v 45, 155, 44)  ->  Höhe 64, zweites Stück ab v 65
+    //   ab 1.20:    blit(…, 256, 44, Textur 256, 64)                     ->  Höhe 64
+    private byte[] titelLogo(String name, byte[] klasse) {
+        ClassNode cn = lies(klasse);
+        int n = 0;
+        for (MethodNode m : cn.methods) {
+            List<AbstractInsnNode> a = befehle(m);
+            for (int i = 0; i + 4 < a.size(); i++) {
+                int w0 = wert(a.get(i)), w1 = wert(a.get(i + 1)), w2 = wert(a.get(i + 2)), w3 = wert(a.get(i + 3));
+                boolean aufrufDanach = a.get(i + 4) instanceof MethodInsnNode;
+                if (w0 == 0 && w1 == 0 && w2 == 155 && w3 == 44 && aufrufDanach) {
+                    setze(m, a, i + 3, 64); n++;
+                } else if (w0 == 0 && w1 == 45 && w2 == 155 && w3 == 44 && aufrufDanach) {
+                    setze(m, a, i + 1, 65); setze(m, a, i + 3, 64); n++;
+                } else if (w0 == 256 && w1 == 44 && w2 == 256 && w3 == 64) {
+                    setze(m, a, i + 1, 64); n++;
+                }
+            }
+        }
+        if (n == 0) return null;
+        System.out.println("[AeroMC] Titel-Logo vergroessert (" + n + ")");
+        return schreibe(cn);
+    }
+
+    // ---------- 2. Logo-Textur ----------
+
+    private byte[] logoStrom(byte[] klasse, boolean alt) {
+        ClassNode cn = lies(klasse);
+        int n = 0;
+        for (MethodNode m : cn.methods) {
+            for (AbstractInsnNode i : befehle(m)) {
+                if (i.getOpcode() != Opcodes.INVOKESTATIC) continue;
+                MethodInsnNode mi = (MethodInsnNode) i;
+                if (!mi.desc.startsWith("(Ljava/io/InputStream;)L") || mi.owner.startsWith("java/")) continue;
+                // Stapel: [strom] -> [strom, helfer] -> [helfer, strom] -> apply -> [neuer strom]
+                InsnList neu = new InsnList();
+                helfer(neu, alt ? Design.LOGO_ALT : Design.LOGO);
+                neu.add(new InsnNode(Opcodes.SWAP));
+                neu.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/util/function/Function", "apply",
+                    "(Ljava/lang/Object;)Ljava/lang/Object;", true));
+                neu.add(new TypeInsnNode(Opcodes.CHECKCAST, "java/io/InputStream"));
+                m.instructions.insertBefore(i, neu);
+                n++;
+            }
+        }
+        if (n == 0) return null;
+        System.out.println("[AeroMC] Ladelogo ersetzt");
+        return schreibe(cn);
+    }
+
+    // ---------- 3. Fenstertitel und -symbol ----------
+
+    private byte[] glfw(byte[] klasse) {
+        ClassNode cn = lies(klasse);
+        int n = 0;
+        for (MethodNode m : cn.methods) {
+            String schluessel = null, typ = null;
+            if ("glfwCreateWindow".equals(m.name) && "(IILjava/lang/CharSequence;JJ)J".equals(m.desc)) {
+                schluessel = Design.TITEL; typ = "java/lang/CharSequence";
+            } else if ("glfwSetWindowTitle".equals(m.name) && "(JLjava/lang/CharSequence;)V".equals(m.desc)) {
+                schluessel = Design.TITEL; typ = "java/lang/CharSequence";
+            } else if ("glfwSetWindowIcon".equals(m.name) && "(JLorg/lwjgl/glfw/GLFWImage$Buffer;)V".equals(m.desc)) {
+                schluessel = Design.ICON; typ = "org/lwjgl/glfw/GLFWImage$Buffer";
+            }
+            if (schluessel == null) continue;
+            // am Anfang: argument = helfer.apply(argument)  (Argument liegt in beiden Fällen in Slot 2)
+            InsnList neu = new InsnList();
+            helfer(neu, schluessel);
+            neu.add(new VarInsnNode(Opcodes.ALOAD, 2));
+            neu.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/util/function/Function", "apply",
+                "(Ljava/lang/Object;)Ljava/lang/Object;", true));
+            neu.add(new TypeInsnNode(Opcodes.CHECKCAST, typ));
+            neu.add(new VarInsnNode(Opcodes.ASTORE, 2));
+            m.instructions.insert(neu);
+            n++;
+        }
+        if (n == 0) return null;
+        System.out.println("[AeroMC] Fenstertitel und -symbol vorbereitet (" + n + ")");
+        return schreibe(cn);
+    }
+
+    // ---------- Hilfen ----------
+
+    /** legt (Function) System.getProperties().get(schluessel) auf den Stapel */
+    private static void helfer(InsnList l, String schluessel) {
+        l.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/lang/System", "getProperties", "()Ljava/util/Properties;", false));
+        l.add(new LdcInsnNode(schluessel));
+        l.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/util/Properties", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", false));
+        l.add(new TypeInsnNode(Opcodes.CHECKCAST, "java/util/function/Function"));
+    }
+
+    private static ClassNode lies(byte[] klasse) {
+        ClassNode cn = new ClassNode();
+        new ClassReader(klasse).accept(cn, 0);
+        return cn;
+    }
+
+    private static byte[] schreibe(ClassNode cn) {
+        ClassWriter w = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        cn.accept(w);
+        return w.toByteArray();
+    }
+
+    /** echte Befehle eines Methodenrumpfs (ohne Labels, Zeilennummern, Frames) */
+    private static List<AbstractInsnNode> befehle(MethodNode m) {
+        List<AbstractInsnNode> l = new ArrayList<>();
+        for (AbstractInsnNode i = m.instructions.getFirst(); i != null; i = i.getNext()) {
+            if (i.getOpcode() >= 0) l.add(i);
+        }
+        return l;
+    }
+
+    private static boolean hatText(ClassNode cn, String text) {
+        for (MethodNode m : cn.methods) {
+            for (AbstractInsnNode i : befehle(m)) {
+                if (i instanceof LdcInsnNode && text.equals(((LdcInsnNode) i).cst)) return true;
+            }
+        }
+        return false;
+    }
+
+    /** Zahlenwert eines Konstanten-Befehls, sonst KEIN_WERT */
+    private static int wert(AbstractInsnNode i) {
+        int op = i.getOpcode();
+        if (op >= Opcodes.ICONST_M1 && op <= Opcodes.ICONST_5) return op - Opcodes.ICONST_0;
+        if (op == Opcodes.BIPUSH || op == Opcodes.SIPUSH) return ((IntInsnNode) i).operand;
+        if (i instanceof LdcInsnNode && ((LdcInsnNode) i).cst instanceof Integer) return (Integer) ((LdcInsnNode) i).cst;
+        return KEIN_WERT;
+    }
+
+    private static boolean aufruf(AbstractInsnNode i, String desc) {
+        return (i.getOpcode() == Opcodes.INVOKESTATIC || i.getOpcode() == Opcodes.INVOKEVIRTUAL)
+            && desc.equals(((MethodInsnNode) i).desc);
+    }
+
+    private static void setze(MethodNode m, List<AbstractInsnNode> a, int index, int v) {
+        m.instructions.set(a.get(index), ersatz(v, a, index));
+    }
+
+    /** neuer Konstanten-Befehl; ersetzt auch den Eintrag in der Befehlsliste */
+    private static AbstractInsnNode ersatz(int v, List<AbstractInsnNode> a, int index) {
+        AbstractInsnNode n = v >= -32768 && v <= 32767 ? new IntInsnNode(Opcodes.SIPUSH, v) : new LdcInsnNode(v);
+        a.set(index, n);
+        return n;
+    }
+
+    private static boolean enthaelt(byte[] daten, byte[] muster) {
+        outer:
+        for (int i = 0, ende = daten.length - muster.length; i <= ende; i++) {
+            for (int k = 0; k < muster.length; k++) {
+                if (daten[i + k] != muster[k]) continue outer;
+            }
+            return true;
+        }
+        return false;
+    }
+}

agent/src/de/aeromc/capes/ModsUmbau.java

@@ -0,0 +1,138 @@
+package de.aeromc.capes;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.nio.charset.StandardCharsets;
+import java.security.ProtectionDomain;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.FrameNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.InsnNode;
+import org.objectweb.asm.tree.JumpInsnNode;
+import org.objectweb.asm.tree.LabelNode;
+import org.objectweb.asm.tree.LdcInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.TypeInsnNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+/**
+ * Mod-Schalter im Pausemenü (Minecraft 1.14 … 26.x, jeder Loader):
+ * Der Knopf „Feedback geben“ wird zum Knopf „Mods verwalten“.
+ *
+ *  1. Seine Adresse (aka.ms/javafeedback bzw. snapshotfeedback) wird zu
+ *     "aeromc://mods" – je nach Version steht sie im Pausemenü selbst
+ *     (bis 1.20) oder in CommonLinks (ab 1.21).
+ *  2. Die Lambdas, über die Minecraft einen Link öffnet (im Pausemenü bzw. in
+ *     ConfirmLinkScreen), fragen vorher den Helfer: Ist es "aeromc://mods",
+ *     öffnet der Launcher das Mod-Fenster und Minecraft zeigt keine Rückfrage.
+ *     Alle anderen Links laufen unverändert weiter.
+ *
+ * Beschriftung bzw. Symbol des Knopfs kommen aus dem Ressourcenpaket.
+ */
+final class ModsUmbau implements ClassFileTransformer {
+    static final String ZIEL = "aeromc://mods";
+    private static final String[] ADRESSEN = {"https://aka.ms/javafeedback?ref=game", "https://aka.ms/snapshotfeedback?ref=game"};
+    private static final byte[] MERKMAL_FEEDBACK = "aka.ms/".getBytes(StandardCharsets.UTF_8);
+    private static final byte[] MERKMAL_LINK = "chat.link.confirm".getBytes(StandardCharsets.UTF_8);
+
+    @Override
+    public byte[] transform(ClassLoader loader, String name, Class<?> umdefiniert, ProtectionDomain pd, byte[] klasse) {
+        if (name == null || umdefiniert != null || name.startsWith("java/") || name.startsWith("jdk/")
+            || name.startsWith("sun/") || name.startsWith("de/aeromc/") || name.startsWith("org/lwjgl/")) return null;
+        try {
+            boolean feedback = enthaelt(klasse, MERKMAL_FEEDBACK);
+            boolean link = enthaelt(klasse, MERKMAL_LINK);
+            if (!feedback && !link) return null;
+            ClassNode cn = new ClassNode();
+            new ClassReader(klasse).accept(cn, 0);
+            int adressen = 0, waechter = 0;
+            for (MethodNode m : cn.methods) {
+                for (AbstractInsnNode i = m.instructions.getFirst(); i != null; i = i.getNext()) {
+                    if (i instanceof LdcInsnNode && istFeedbackAdresse(((LdcInsnNode) i).cst)) {
+                        ((LdcInsnNode) i).cst = ZIEL;
+                        adressen++;
+                    }
+                }
+            }
+            if (adressen == 0 && !link) return null;
+            for (MethodNode m : cn.methods) {
+                if ((m.access & Opcodes.ACC_SYNTHETIC) == 0 || Type.getReturnType(m.desc) != Type.VOID_TYPE) continue;
+                int slot = adressParameter(m);
+                boolean konstante = slot < 0 && enthaeltZiel(m);
+                if (slot < 0 && !konstante) continue;
+                if (frameAmAnfang(m)) continue;    // nicht sicher erweiterbar
+                InsnList w = new InsnList();
+                w.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/lang/System", "getProperties", "()Ljava/util/Properties;", false));
+                w.add(new LdcInsnNode(Design.MODS));
+                w.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/util/Properties", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", false));
+                w.add(new TypeInsnNode(Opcodes.CHECKCAST, "java/util/function/Function"));
+                if (slot >= 0) w.add(new VarInsnNode(Opcodes.ALOAD, slot)); else w.add(new LdcInsnNode(ZIEL));
+                w.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/util/function/Function", "apply", "(Ljava/lang/Object;)Ljava/lang/Object;", true));
+                w.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/Boolean", "TRUE", "Ljava/lang/Boolean;"));
+                LabelNode weiter = new LabelNode();
+                w.add(new JumpInsnNode(Opcodes.IF_ACMPNE, weiter));
+                w.add(new InsnNode(Opcodes.RETURN));
+                w.add(weiter);
+                w.add(new FrameNode(Opcodes.F_SAME, 0, null, 0, null));
+                m.instructions.insert(w);
+                waechter++;
+            }
+            if (adressen == 0 && waechter == 0) return null;
+            System.out.println("[AeroMC] Mod-Schalter vorbereitet (Adressen " + adressen + ", Links " + waechter + ")");
+            ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+            cn.accept(cw);
+            return cw.toByteArray();
+        } catch (Throwable t) {
+            System.out.println("[AeroMC] Mod-Schalter: " + name + " nicht angepasst: " + t);
+            return null;
+        }
+    }
+
+    private static boolean istFeedbackAdresse(Object cst) {
+        for (String a : ADRESSEN) if (a.equals(cst)) return true;
+        return false;
+    }
+
+    /** Slot des ersten Parameters vom Typ String oder URI, sonst -1 */
+    private static int adressParameter(MethodNode m) {
+        int slot = (m.access & Opcodes.ACC_STATIC) != 0 ? 0 : 1;
+        for (Type t : Type.getArgumentTypes(m.desc)) {
+            String d = t.getDescriptor();
+            if ("Ljava/lang/String;".equals(d) || "Ljava/net/URI;".equals(d)) return slot;
+            slot += t.getSize();
+        }
+        return -1;
+    }
+
+    private static boolean enthaeltZiel(MethodNode m) {
+        for (AbstractInsnNode i = m.instructions.getFirst(); i != null; i = i.getNext()) {
+            if (i instanceof LdcInsnNode && ZIEL.equals(((LdcInsnNode) i).cst)) return true;
+        }
+        return false;
+    }
+
+    /** steht vor dem ersten echten Befehl schon ein Frame (Sprungziel am Anfang)? */
+    private static boolean frameAmAnfang(MethodNode m) {
+        for (AbstractInsnNode i = m.instructions.getFirst(); i != null; i = i.getNext()) {
+            if (i instanceof FrameNode) return true;
+            if (i.getOpcode() >= 0) return false;
+        }
+        return false;
+    }
+
+    private static boolean enthaelt(byte[] daten, byte[] muster) {
+        outer:
+        for (int i = 0, ende = daten.length - muster.length; i <= ende; i++) {
+            for (int k = 0; k < muster.length; k++) if (daten[i + k] != muster[k]) continue outer;
+            return true;
+        }
+        return false;
+    }
+}

agent/src/de/aeromc/capes/Nachschlagen.java

@@ -0,0 +1,183 @@
+package de.aeromc.capes;
+
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiFunction;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Wird aus authlib heraus mit (ergebnis, argument) aufgerufen und gibt das
+ * Ergebnis zurück – mit eingesetztem AeroMC-Umhang, falls der Spieler einen hat.
+ * Arbeitet nur über Reflexion, damit es zu jeder authlib-Fassung passt, und
+ * fängt jeden Fehler ab: im schlimmsten Fall bleibt alles wie ohne Agent.
+ */
+public final class Nachschlagen implements BiFunction<Object, Object, Object> {
+    public static final String STANDARD_BASIS = "https://viper-network.de/wp-json/aeromc/v1";
+    private static final long GEFUNDEN_MS = 5 * 60 * 1000L;
+    private static final long KEINER_MS = 2 * 60 * 1000L;
+    private static final Pattern URL_MUSTER = Pattern.compile("\"url\"\\s*:\\s*\"((?:[^\"\\\\]|\\\\.)*)\"");
+    private static final Pattern ID_MUSTER = Pattern.compile("\"profileId\"\\s*:\\s*\"([0-9a-fA-F-]{32,36})\"");
+
+    private static final class Eintrag {
+        final String url; // null = kein Umhang
+        final long zeit;
+        Eintrag(String url) { this.url = url; this.zeit = System.currentTimeMillis(); }
+        boolean frisch() { return System.currentTimeMillis() - zeit < (url != null ? GEFUNDEN_MS : KEINER_MS); }
+    }
+
+    private final String basis;
+    private final Map<String, Eintrag> speicher = new ConcurrentHashMap<>();
+    private final Map<String, Boolean> unterwegs = new ConcurrentHashMap<>();
+    private final Map<String, Boolean> gemeldet = new ConcurrentHashMap<>();
+
+    public Nachschlagen(String basis) {
+        this.basis = basis.endsWith("/") ? basis.substring(0, basis.length() - 1) : basis;
+    }
+
+    @Override
+    public Object apply(Object ergebnis, Object argument) {
+        try {
+            String id = spielerId(argument);
+            if (id == null) return ergebnis;
+            String url = umhangUrl(id);
+            if (url == null) return ergebnis;
+            Object neu = mitUmhang(ergebnis, url, argument);
+            if (neu != ergebnis && gemeldet.putIfAbsent(id, Boolean.TRUE) == null) {
+                System.out.println("[AeroMC] Umhang fuer " + id + " eingesetzt");
+            }
+            return neu;
+        } catch (Throwable t) {
+            return ergebnis;
+        }
+    }
+
+    // ---------- Spieler erkennen ----------
+    private static String spielerId(Object argument) throws Exception {
+        if (argument == null) return null;
+        String klasse = argument.getClass().getName();
+        if (klasse.endsWith("GameProfile")) {
+            Object id = rufe(argument, "getId", "id");
+            return id instanceof UUID ? hex((UUID) id) : null;
+        }
+        if (klasse.endsWith("Property")) {
+            Object wert = rufe(argument, "getValue", "value");
+            if (!(wert instanceof String)) return null;
+            String json = new String(Base64.getDecoder().decode(((String) wert).trim()), StandardCharsets.UTF_8);
+            Matcher m = ID_MUSTER.matcher(json);
+            return m.find() ? m.group(1).replace("-", "").toLowerCase() : null;
+        }
+        return null;
+    }
+
+    private static String hex(UUID u) {
+        return u.toString().replace("-", "").toLowerCase();
+    }
+
+    private static Object rufe(Object ziel, String... namen) throws Exception {
+        for (String n : namen) {
+            try {
+                Method m = ziel.getClass().getMethod(n);
+                return m.invoke(ziel);
+            } catch (NoSuchMethodException ignoriert) {
+                // nächster Name
+            }
+        }
+        return null;
+    }
+
+    // ---------- Umhang-Server ----------
+    private String umhangUrl(String id) {
+        Eintrag e = speicher.get(id);
+        if (e != null && e.frisch()) return e.url;
+        // Auf dem Haupt-/Render-Thread nie warten: dort nur im Hintergrund holen;
+        // Minecraft fragt beim nächsten Laden des Spielers erneut
+        String thread = Thread.currentThread().getName();
+        boolean hauptThread = thread.equals("Render thread") || thread.equals("Client thread") || thread.equals("main");
+        if (hauptThread) {
+            if (unterwegs.putIfAbsent(id, Boolean.TRUE) == null) {
+                Thread t = new Thread(() -> { try { hole(id); } finally { unterwegs.remove(id); } }, "AeroMC-Umhang");
+                t.setDaemon(true);
+                t.start();
+            }
+            return e != null ? e.url : null;
+        }
+        return hole(id);
+    }
+
+    private String hole(String id) {
+        try {
+            HttpURLConnection c = (HttpURLConnection) new URL(basis + "/capes?uuids=" + id).openConnection();
+            c.setConnectTimeout(2000);
+            c.setReadTimeout(3000);
+            c.setRequestProperty("User-Agent", "AeroMC-Umhang/1.0");
+            c.setRequestProperty("Accept", "application/json");
+            if (c.getResponseCode() != 200) {
+                speicher.put(id, new Eintrag(null));
+                return null;
+            }
+            String json;
+            try (InputStream in = c.getInputStream()) {
+                ByteArrayOutputStream puffer = new ByteArrayOutputStream();
+                byte[] b = new byte[4096];
+                int n;
+                while ((n = in.read(b)) > 0 && puffer.size() < 65536) puffer.write(b, 0, n);
+                json = new String(puffer.toByteArray(), StandardCharsets.UTF_8);
+            }
+            String url = null;
+            Matcher m = URL_MUSTER.matcher(json);
+            if (json.contains("\"" + id + "\"") && m.find()) {
+                url = m.group(1).replace("\\/", "/");
+                if (!url.startsWith("https://")) url = null;
+            }
+            speicher.put(id, new Eintrag(url));
+            return url;
+        } catch (Throwable t) {
+            // Server nicht erreichbar: kurz merken, damit nicht jeder Spieler hängt
+            speicher.put(id, new Eintrag(null));
+            return null;
+        }
+    }
+
+    // ---------- Umhang einsetzen ----------
+    private static Object textur(ClassLoader cl, String url) throws Exception {
+        Class<?> k = Class.forName("com.mojang.authlib.minecraft.MinecraftProfileTexture", false, cl);
+        Constructor<?> ctor = k.getConstructor(String.class, Map.class);
+        return ctor.newInstance(url, null);
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private static Object mitUmhang(Object ergebnis, String url, Object argument) throws Exception {
+        ClassLoader cl = argument.getClass().getClassLoader();
+        if (ergebnis instanceof Map) {
+            // authlib 1–4: Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>
+            Class<?> typ = Class.forName("com.mojang.authlib.minecraft.MinecraftProfileTexture$Type", false, cl);
+            Object cape = Enum.valueOf((Class<Enum>) typ, "CAPE");
+            Map neu = new HashMap((Map) ergebnis);
+            neu.put(cape, textur(cl, url));
+            return neu;
+        }
+        if (ergebnis == null) return null;
+        // authlib 5+: record MinecraftProfileTextures(skin, cape, elytra, signatureState)
+        Class<?> k = ergebnis.getClass();
+        Object skin = k.getMethod("skin").invoke(ergebnis);
+        Object elytra = k.getMethod("elytra").invoke(ergebnis);
+        Object signatur = k.getMethod("signatureState").invoke(ergebnis);
+        for (Constructor<?> ctor : k.getConstructors()) {
+            if (ctor.getParameterCount() == 4) {
+                return ctor.newInstance(skin, textur(cl, url), elytra, signatur);
+            }
+        }
+        return ergebnis;
+    }
+}

agent/src/de/aeromc/capes/Umbau.java

@@ -0,0 +1,78 @@
+package de.aeromc.capes;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.security.ProtectionDomain;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * Baut YggdrasilMinecraftSessionService beim Laden um: vor jedem "return" der
+ * Textur-Methode wird das Ergebnis an den Nachschlage-Dienst gereicht, der den
+ * AeroMC-Umhang einsetzt.
+ *
+ *   authlib 5+ (Minecraft 1.20.2 … 26.x):
+ *     MinecraftProfileTextures unpackTextures(Property)
+ *   authlib 1–4 (Minecraft 1.8 … 1.20.1):
+ *     Map<Type, MinecraftProfileTexture> getTextures(GameProfile, boolean)
+ *
+ * Eingefügt wird nur geradliniger Code ohne Sprünge – die vorhandenen
+ * Stack-Map-Frames bleiben gültig, es muss nichts neu berechnet werden.
+ */
+final class Umbau implements ClassFileTransformer {
+    static final String ZIEL = "com/mojang/authlib/yggdrasil/YggdrasilMinecraftSessionService";
+
+    @Override
+    public byte[] transform(ClassLoader loader, String name, Class<?> umdefiniert, ProtectionDomain pd, byte[] klasse) {
+        if (!ZIEL.equals(name) || umdefiniert != null) return null;
+        try {
+            ClassReader leser = new ClassReader(klasse);
+            ClassWriter schreiber = new ClassWriter(leser, ClassWriter.COMPUTE_MAXS);
+            final int[] umgebaut = {0};
+            leser.accept(new ClassVisitor(Opcodes.ASM9, schreiber) {
+                @Override
+                public MethodVisitor visitMethod(int zugriff, String mname, String desc, String sig, String[] ausn) {
+                    MethodVisitor mv = super.visitMethod(zugriff, mname, desc, sig, ausn);
+                    if ((zugriff & Opcodes.ACC_STATIC) != 0) return mv;
+                    String rueckgabe = null;
+                    if ("unpackTextures".equals(mname) && desc.startsWith("(Lcom/mojang/authlib/properties/Property;)L")) {
+                        rueckgabe = desc.substring(desc.indexOf(")L") + 2, desc.length() - 1);
+                    } else if ("getTextures".equals(mname) && desc.equals("(Lcom/mojang/authlib/GameProfile;Z)Ljava/util/Map;")) {
+                        rueckgabe = "java/util/Map";
+                    }
+                    if (rueckgabe == null) return mv;
+                    umgebaut[0]++;
+                    final String typ = rueckgabe;
+                    return new MethodVisitor(Opcodes.ASM9, mv) {
+                        @Override
+                        public void visitInsn(int op) {
+                            if (op == Opcodes.ARETURN) {
+                                // Stapel: [ergebnis] -> [dienst, ergebnis, argument] -> apply -> [neu]
+                                super.visitVarInsn(Opcodes.ALOAD, 1);
+                                super.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", "getProperties", "()Ljava/util/Properties;", false);
+                                super.visitLdcInsn(Agent.SCHLUESSEL);
+                                super.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/util/Properties", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", false);
+                                super.visitTypeInsn(Opcodes.CHECKCAST, "java/util/function/BiFunction");
+                                super.visitInsn(Opcodes.DUP_X2);
+                                super.visitInsn(Opcodes.POP);
+                                super.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/function/BiFunction", "apply",
+                                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", true);
+                                super.visitTypeInsn(Opcodes.CHECKCAST, typ);
+                            }
+                            super.visitInsn(op);
+                        }
+                    };
+                }
+            }, 0);
+            if (umgebaut[0] == 0) return null;
+            System.out.println("[AeroMC] authlib fuer Umhaenge vorbereitet (" + umgebaut[0] + " Methode)");
+            return schreiber.toByteArray();
+        } catch (Throwable t) {
+            System.out.println("[AeroMC] authlib konnte nicht angepasst werden: " + t);
+            return null;
+        }
+    }
+}

agent/tools/Shade.java

@@ -0,0 +1,80 @@
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.Enumeration;
+import java.util.jar.Attributes;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.commons.ClassRemapper;
+import org.objectweb.asm.commons.Remapper;
+
+/**
+ * Baut die Agent-Datei: eigene Klassen + ASM, dabei org/objectweb/asm nach
+ * de/aeromc/capes/asm umbenannt. So kann das ASM von Fabric/Forge (das auf
+ * demselben Klassenpfad liegt) nie mit unserem verwechselt werden.
+ *
+ * Aufruf: java Shade <ziel.jar> <klassenordner> <asm.jar> [weitere ASM-Jars, z. B. asm-tree]
+ */
+public class Shade {
+    static final Remapper UMBENENNEN = new Remapper() {
+        @Override
+        public String map(String name) {
+            return name.startsWith("org/objectweb/asm/") ? "de/aeromc/capes/asm/" + name.substring(18) : name;
+        }
+    };
+
+    static byte[] umbenennen(byte[] klasse) {
+        ClassReader r = new ClassReader(klasse);
+        ClassWriter w = new ClassWriter(0);
+        r.accept(new ClassRemapper(w, UMBENENNEN), 0);
+        return w.toByteArray();
+    }
+
+    static byte[] lies(InputStream in) throws Exception {
+        ByteArrayOutputStream b = new ByteArrayOutputStream();
+        byte[] p = new byte[8192];
+        int n;
+        while ((n = in.read(p)) > 0) b.write(p, 0, n);
+        return b.toByteArray();
+    }
+
+    public static void main(String[] a) throws Exception {
+        Manifest mf = new Manifest();
+        Attributes at = mf.getMainAttributes();
+        at.put(Attributes.Name.MANIFEST_VERSION, "1.0");
+        at.putValue("Premain-Class", "de.aeromc.capes.Agent");
+        at.putValue("Agent-Class", "de.aeromc.capes.Agent");
+        at.putValue("Can-Retransform-Classes", "false");
+        at.putValue("Implementation-Title", "AeroMC Agent (Umhaenge, Spieldesign)");
+        try (JarOutputStream out = new JarOutputStream(new FileOutputStream(a[0]), mf)) {
+            // eigene Klassen
+            File basis = new File(a[1]);
+            for (File f : Files.walk(basis.toPath()).map(p -> p.toFile()).filter(f -> f.getName().endsWith(".class")).toArray(File[]::new)) {
+                String name = basis.toPath().relativize(f.toPath()).toString().replace('\\', '/');
+                out.putNextEntry(new JarEntry(name));
+                out.write(umbenennen(Files.readAllBytes(f.toPath())));
+                out.closeEntry();
+            }
+            // ASM (umbenannt), ohne Modul-Infos und Signaturen
+            for (int j = 2; j < a.length; j++) try (JarFile asm = new JarFile(a[j])) {
+                Enumeration<JarEntry> e = asm.entries();
+                while (e.hasMoreElements()) {
+                    JarEntry je = e.nextElement();
+                    String n = je.getName();
+                    if (!n.startsWith("org/objectweb/asm/") || !n.endsWith(".class")) continue;
+                    byte[] neu = umbenennen(lies(asm.getInputStream(je)));
+                    out.putNextEntry(new JarEntry("de/aeromc/capes/asm/" + n.substring(18)));
+                    out.write(neu);
+                    out.closeEntry();
+                }
+            }
+        }
+    }
+}

installer/Installer.cs

@@ -181,9 +181,35 @@ public static class Installer
             k.SetValue("NoRepair", 1, RegistryValueKind.DWord);
         }
 
+        progress.Report((0.98, "Installation wird abgeschlossen …"));
+        Vorwaermen(exe);
+
         progress.Report((1.0, "Fertig"));
     }
 
+    /// <summary>
+    /// Startet AeroMC einmal kurz mit "--aeromc-vorwaermen" – die App beendet sich
+    /// damit sofort wieder (siehe src/main.js). Windows Defender prüft eine neue,
+    /// noch unbekannte EXE beim ersten Start mehrere Sekunden lang (gemessen: ~8 s);
+    /// das passiert so während des Fortschrittsbalkens und nicht erst beim Klick
+    /// auf "Fertigstellen". Das Ergebnis merkt sich Windows, der echte Start ist
+    /// danach sofort da.
+    /// </summary>
+    private static void Vorwaermen(string exe)
+    {
+        try
+        {
+            using var p = Process.Start(new ProcessStartInfo(exe, "--aeromc-vorwaermen")
+            {
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                WorkingDirectory = Path.GetDirectoryName(exe)!,
+            });
+            if (p != null && !p.WaitForExit(30000)) { try { p.Kill(); } catch { } }
+        }
+        catch { /* nur eine Beschleunigung – Fehler sind egal */ }
+    }
+
     private static List<string> TopLevelNames(ZipArchive zip) =>
         zip.Entries
             .Select(e => e.FullName.Replace('\\', '/').Split('/')[0])

installer/MainWindow.xaml.cs

@@ -300,7 +300,16 @@ public partial class MainWindow : Window
                 await RunInstall(DirBox.Text.Trim(), DesktopLinkBox.IsChecked == true, update: false);
                 break;
             case PageNumProgress:
-                if (LaunchBox.IsChecked == true) StartApp();
+                // Start im Hintergrund: Process.Start kann blockieren, solange Windows
+                // die EXE prüft – das Fenster darf dabei nie einfrieren
+                if (LaunchBox.IsChecked == true)
+                {
+                    _busy = true;
+                    NextButton.IsEnabled = false;
+                    NextButton.Content = "AeroMC startet …";
+                    await Task.Run(StartApp);
+                    _busy = false;
+                }
                 Close();
                 break;
         }

installer/obj/AeroMCSetup.csproj.nuget.dgspec.json

@@ -5,7 +5,7 @@
   },
   "projects": {
     "C:\\Users\\Viper\\Desktop\\AeroMC-Launcher\\installer\\AeroMCSetup.csproj": {
-      "version": "1.1.6",
+      "version": "1.2.3",
       "restore": {
         "projectUniqueName": "C:\\Users\\Viper\\Desktop\\AeroMC-Launcher\\installer\\AeroMCSetup.csproj",
         "projectName": "AeroMC-Setup",

installer/obj/Release/net48/AeroMCSetup.AssemblyInfo.cs

@@ -14,11 +14,11 @@ using System.Reflection;
 [assembly: System.Reflection.AssemblyConfigurationAttribute("Release")]
 [assembly: System.Reflection.AssemblyCopyrightAttribute("Copyright (c) M_Viper. Alle Rechte vorbehalten.")]
 [assembly: System.Reflection.AssemblyDescriptionAttribute("Installiert AeroMC")]
-[assembly: System.Reflection.AssemblyFileVersionAttribute("1.1.6.0")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.2.3.0")]
-[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.1.6")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.2.3")]
 [assembly: System.Reflection.AssemblyProductAttribute("AeroMC Setup")]
 [assembly: System.Reflection.AssemblyTitleAttribute("AeroMC Setup")]
-[assembly: System.Reflection.AssemblyVersionAttribute("1.1.6.0")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.2.3.0")]
 [assembly: System.Resources.NeutralResourcesLanguageAttribute("de-DE")]
 
 // Von der MSBuild WriteCodeFragment-Klasse generiert.

installer/obj/Release/net48/AeroMCSetup.AssemblyInfoInputs.cache

@@ -1 +1 @@
-5b6f28fb41c3f0e5fe29f9489cfc618a7d6593efb71d420030e4a1d4fdb4066e
+111db8ee3dc7193961107c73afd8913fff02b92fd4e49b8b7e4bf051181600bd

installer/obj/project.assets.json

@@ -418,7 +418,7 @@
     "C:\\Users\\Viper\\.nuget\\packages\\": {}
   },
   "project": {
-    "version": "1.1.6",
+    "version": "1.2.3",
     "restore": {
       "projectUniqueName": "C:\\Users\\Viper\\Desktop\\AeroMC-Launcher\\installer\\AeroMCSetup.csproj",
       "projectName": "AeroMC-Setup",

installer/obj/project.nuget.cache

@@ -1,6 +1,6 @@
 {
   "version": 2,
-  "dgSpecHash": "lJiGEWCFg6M=",
+  "dgSpecHash": "5nf4o8NXPS0=",
   "success": true,
   "projectFilePath": "C:\\Users\\Viper\\Desktop\\AeroMC-Launcher\\installer\\AeroMCSetup.csproj",
   "expectedPackageFiles": [

mod/MODRINTH.md

@@ -0,0 +1,42 @@
+# AeroMC Capes
+
+Shows the **custom capes (including HD up to 1024×512)** of players who designed their cape in the
+[AeroMC Launcher](https://aeromc.viper.ipv64.net) – right in the game, even if you use a different
+launcher yourself.
+
+## How it works
+- Drop the mod into your `mods` folder – done. No configuration, no Fabric API required.
+- Whenever Minecraft loads a player's skin, the mod asks the AeroMC server whether that player has
+  an AeroMC cape and shows it instead of the regular cape.
+- If a player has no AeroMC cape, nothing changes (official Mojang cape or none).
+- **Client-side only** – servers don't need anything.
+
+## Compatibility
+- **Fabric** and **Quilt**
+- **One jar for all versions**: Minecraft 1.14 to 26.x
+- Works with old Fabric Loader versions too (0.10 and newer)
+- Players using the AeroMC Launcher don't need this mod (the launcher already does this on its
+  own) – but having it installed doesn't hurt either.
+
+## Privacy
+The mod only sends the (public) UUIDs of players whose skins are currently being loaded to
+`viper-network.de` to look up their capes. Results are cached for a few minutes.
+No account or login data is ever transmitted.
+
+## Create your own cape
+In the AeroMC Launcher: click your account name (top right) → **Skin ändern…** (Change skin) →
+in the **Umhang** (Cape) section click **Gestalten…** (Design). You can paint your cape pixel by
+pixel or insert any image, in sizes from 64×32 up to HD 1024×512.
+
+---
+
+### Hinweise zum Hochladen (nicht Teil der Beschreibung)
+- Name: AeroMC Capes (URL bleibt `aeromc-umhaenge`)
+- Kurzbeschreibung: Shows custom capes (HD up to 1024×512) made in the AeroMC Launcher – even if you use another launcher. One jar for 1.14–26.x, client-side.
+- Datei: `dist/aeromc-umhaenge-fabric-1.0.0.jar`
+- Loader: Fabric, Quilt · Umgebung: Client · Server: nicht nötig
+- Spielversionen: alle Releases von 1.14 bis zur aktuellen
+- Kategorien: Sozial (hervorgehoben), Werkzeug („Cosmetic“ gibt es für Mods nicht)
+- Abhängigkeiten: keine
+- Lizenz: aktuell „All Rights Reserved“ (in `fabric.mod.json`) – Modrinth akzeptiert das, eine
+  offene Lizenz (z. B. MIT) wirkt aber vertrauenswürdiger.

mod/resources/aeromc-capes.mixins.json

@@ -0,0 +1,10 @@
+{
+  "required": false,
+  "minVersion": "0.8",
+  "package": "de.aeromc.capes.mixin",
+  "compatibilityLevel": "JAVA_8",
+  "client": ["SessionServiceMixin", "SkinLaderMixin"],
+  "injectors": {
+    "defaultRequire": 0
+  }
+}

mod/resources/fabric.mod.json

@@ -0,0 +1,18 @@
+{
+  "schemaVersion": 1,
+  "id": "aeromc-capes",
+  "version": "1.0.0",
+  "name": "AeroMC Umhänge",
+  "description": "Zeigt die eigenen Umhänge (auch HD) von AeroMC-Spielern im Spiel – gestaltet im AeroMC Launcher. Nur auf dem Client nötig. Funktioniert mit jeder Minecraft-Version, die Fabric unterstützt.",
+  "authors": ["M_Viper"],
+  "contact": {
+    "homepage": "https://aeromc.viper.ipv64.net"
+  },
+  "license": "LicenseRef-All-Rights-Reserved",
+  "icon": "assets/aeromc-capes/icon.png",
+  "environment": "client",
+  "mixins": ["aeromc-capes.mixins.json"],
+  "depends": {
+    "fabricloader": ">=0.10.0"
+  }
+}

mod/src/de/aeromc/capes/mixin/SessionServiceMixin.java

@@ -0,0 +1,48 @@
+package de.aeromc.capes.mixin;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import com.mojang.authlib.yggdrasil.YggdrasilMinecraftSessionService;
+import de.aeromc.capes.mod.Umhaenge;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+/**
+ * Hängt sich an die Textur-Methoden von authlib (beide Fassungen, siehe
+ * agent/…/Umbau.java). require = 0: Es greift immer nur die Methode, die es in
+ * der jeweiligen authlib-Fassung gibt, die andere wird still übersprungen.
+ * remap = false: authlib ist nicht verschleiert, Namen bleiben wie sie sind.
+ */
+@Mixin(value = YggdrasilMinecraftSessionService.class, remap = false)
+public abstract class SessionServiceMixin {
+
+    // wird in den statischen Initialisierer von authlib übernommen: zeigt im Spielprotokoll, dass der Mod greift
+    static {
+        Umhaenge.authlibGreift = true;
+        Umhaenge.meldeAktiv("authlib");
+    }
+
+    // authlib 5+ (Minecraft 1.20.2 … 26.x)
+    @Inject(method = "unpackTextures", at = @At("RETURN"), cancellable = true, remap = false, require = 0)
+    private void aeromc$neu(Property eigenschaft, CallbackInfoReturnable<Object> cir) {
+        aeromc$ersetze(cir, eigenschaft);
+    }
+
+    // authlib 1–4 (Minecraft 1.14 … 1.20.1)
+    @Inject(method = "getTextures(Lcom/mojang/authlib/GameProfile;Z)Ljava/util/Map;", at = @At("RETURN"), cancellable = true, remap = false, require = 0)
+    private void aeromc$alt(GameProfile profil, boolean sicher, CallbackInfoReturnable<Object> cir) {
+        aeromc$ersetze(cir, profil);
+    }
+
+    private static void aeromc$ersetze(CallbackInfoReturnable<Object> cir, Object argument) {
+        try {
+            Object alt = cir.getReturnValue();
+            Object neu = Umhaenge.mitUmhang(alt, argument);
+            if (neu != alt) cir.setReturnValue(neu);
+        } catch (Throwable ignoriert) {
+            // im Zweifel bleibt alles wie ohne Mod
+        }
+    }
+}

mod/src/de/aeromc/capes/mixin/SkinLaderMixin.java

@@ -0,0 +1,38 @@
+package de.aeromc.capes.mixin;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.minecraft.MinecraftSessionService;
+import de.aeromc.capes.mod.Umhaenge;
+import net.minecraft.class_1071;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import java.util.Map;
+
+/**
+ * Zweiter Weg für alte Fabric Loader (vor 0.12): Die lassen Mixins nur in
+ * Minecraft selbst zu, nicht in authlib – SessionServiceMixin greift dort also
+ * nie. Deshalb wird hier der Aufruf von getTextures im Skin-Lader von Minecraft
+ * (PlayerSkinProvider = class_1071, Intermediary-Name, gleich in 1.14 … 1.20.1)
+ * umgeleitet. Bei neuen Loadern erledigt das bereits SessionServiceMixin, dann
+ * reicht diese Umleitung das Ergebnis nur unverändert durch.
+ */
+@Mixin(value = class_1071.class, targets = "net.minecraft.class_1071$1", remap = false)
+public abstract class SkinLaderMixin {
+
+    @Redirect(method = "*", at = @At(value = "INVOKE", remap = false,
+            target = "Lcom/mojang/authlib/minecraft/MinecraftSessionService;getTextures(Lcom/mojang/authlib/GameProfile;Z)Ljava/util/Map;"),
+            remap = false, require = 0)
+    private Map aeromc$texturen(MinecraftSessionService dienst, GameProfile profil, boolean sicher) {
+        Map texturen = dienst.getTextures(profil, sicher);
+        if (Umhaenge.authlibGreift) return texturen;
+        Umhaenge.meldeAktiv("Skin-Lader");
+        try {
+            Object neu = Umhaenge.mitUmhang(texturen, profil);
+            return neu instanceof Map ? (Map) neu : texturen;
+        } catch (Throwable ignoriert) {
+            return texturen;
+        }
+    }
+}

mod/src/de/aeromc/capes/mod/Umhaenge.java

@@ -0,0 +1,39 @@
+package de.aeromc.capes.mod;
+
+import de.aeromc.capes.Nachschlagen;
+
+/**
+ * AeroMC Umhänge – Fabric/Quilt-Mod für Spieler, die NICHT den AeroMC Launcher
+ * nutzen. Er macht dasselbe wie der Umhang-Agent des Launchers: In Mojangs
+ * authlib wird der AeroMC-Umhang eines Spielers eingesetzt, sobald Minecraft
+ * dessen Skin lädt. Da nur authlib angepasst wird (nicht Minecraft selbst),
+ * passt ein und derselbe Mod zu jeder Minecraft-Version, die Fabric kennt.
+ * Alte Fabric Loader (vor 0.12) erlauben keine Mixins in authlib, dort greift
+ * stattdessen SkinLaderMixin im Skin-Lader von Minecraft.
+ */
+public final class Umhaenge {
+    private static final Nachschlagen DIENST = new Nachschlagen(Nachschlagen.STANDARD_BASIS);
+
+    /** true, sobald SessionServiceMixin in authlib eingebaut wurde (dann ist SkinLaderMixin überflüssig). */
+    public static volatile boolean authlibGreift;
+    private static volatile boolean gemeldet;
+
+    private Umhaenge() {}
+
+    /** Schreibt einmalig ins Spielprotokoll, dass (und über welchen Weg) der Mod greift. */
+    public static void meldeAktiv(String weg) {
+        if (gemeldet || agentAktiv()) return;
+        gemeldet = true;
+        System.out.println("[AeroMC] Umhang-Mod aktiv (" + weg + ")");
+    }
+
+    /** Läuft das Spiel über den AeroMC Launcher, setzt schon dessen Agent die Umhänge ein. */
+    public static boolean agentAktiv() {
+        return System.getProperties().containsKey("aeromc.capes.hook");
+    }
+
+    public static Object mitUmhang(Object ergebnis, Object argument) {
+        if (agentAktiv()) return ergebnis;
+        return DIENST.apply(ergebnis, argument);
+    }
+}

mod/stubs/net/minecraft/class_1071.java

@@ -0,0 +1,4 @@
+package net.minecraft;
+
+/** Nur zum Kompilieren: Platzhalter für Minecrafts PlayerSkinProvider (Intermediary-Name). Kommt nicht ins Mod-Jar. */
+public class class_1071 {}

package.json

@@ -1,7 +1,7 @@
 {
   "name": "aeromc",
   "productName": "AeroMC",
-  "version": "1.1.6",
+  "version": "1.2.3",
   "description": "AeroMC – Instanz-basierter Minecraft-Launcher (à la MultiMC/Prism)",
   "homepage": "https://m-viper.de",
   "launcherWebsite": "https://aeromc.viper.ipv64.net",
@@ -11,10 +11,10 @@
   "private": true,
   "scripts": {
     "start": "electron .",
-    "prebuild": "node scripts/write-build-config.js",
+    "prebuild": "node scripts/pruefe-version.js && node scripts/write-build-config.js",
-    "prebuild:portable": "node scripts/write-build-config.js",
+    "prebuild:portable": "node scripts/pruefe-version.js && node scripts/write-build-config.js",
-    "build": "electron-builder --win dir && node scripts/build-setup.js",
+    "build": "electron-builder --win dir && node scripts/build-setup.js && node scripts/sign-release.js setup",
-    "build:portable": "electron-builder --win portable --x64 && node -e \"const fs=require('fs');const path=require('path');['dist/builder-debug.yml','dist/builder-effective-config.yaml','dist/win-unpacked'].forEach((target)=>fs.rmSync(target,{recursive:true,force:true}));if(fs.existsSync('dist')){const source=path.join('dist','AeroMC.exe');const target=path.join('dist','AeroMC-Portable.exe');if(fs.existsSync(target))fs.rmSync(target,{force:true});if(fs.existsSync(source))fs.renameSync(source,target);for(const name of fs.readdirSync('dist')){if((name.endsWith('.exe')&&name!=='AeroMC-Setup.exe'&&name!=='AeroMC-Portable.exe')||name.endsWith('.blockmap')){fs.rmSync(path.join('dist',name),{force:true})}}}\""
+    "build:portable": "electron-builder --win portable --x64 && node -e \"const fs=require('fs');const path=require('path');['dist/builder-debug.yml','dist/builder-effective-config.yaml','dist/win-unpacked'].forEach((target)=>fs.rmSync(target,{recursive:true,force:true}));if(fs.existsSync('dist')){const source=path.join('dist','AeroMC.exe');const target=path.join('dist','AeroMC-Portable.exe');if(fs.existsSync(target))fs.rmSync(target,{force:true});if(fs.existsSync(source))fs.renameSync(source,target);for(const name of fs.readdirSync('dist')){if((name.endsWith('.exe')&&name!=='AeroMC-Setup.exe'&&name!=='AeroMC-Portable.exe')||name.endsWith('.blockmap')){fs.rmSync(path.join('dist',name),{force:true})}}}\" && node scripts/sign-release.js portable"
   },
   "build": {
     "appId": "com.aeromc.launcher",
@@ -34,11 +34,18 @@
     "win": {
       "target": "dir",
       "icon": "src/assets/icon.ico"
+    },
+    "electronFuses": {
+      "runAsNode": false,
+      "enableNodeOptionsEnvironmentVariable": false,
+      "enableNodeCliInspectArguments": false,
+      "enableEmbeddedAsarIntegrityValidation": true,
+      "onlyLoadAppFromAsar": true
     }
   },
   "devDependencies": {
-    "electron": "^28.0.0",
+    "electron": "^44.6.0",
-    "electron-builder": "^24.0.0"
+    "electron-builder": "^26.15.3"
   },
   "dependencies": {
     "@xhayper/discord-rpc": "^1.3.4",
@@ -50,5 +57,8 @@
     "sql.js": "^1.14.2",
     "undici": "^6.28.0",
     "unzipper": "^0.12.5"
+  },
+  "overrides": {
+    "brace-expansion@^2.0.0": "^2.1.7"
   }
 }

scripts/build-agent.js

@@ -0,0 +1,73 @@
+'use strict';
+
+/*
+ * build-agent.js – baut src/assets/agent/aeromc-capes.jar (AeroMC-Umhang-Agent)
+ * ------------------------------------------------------------------------------
+ * Braucht ein JDK (javac/java, ab 11) und ASM 9 – beides wird nur beim Bauen
+ * gebraucht, die fertige Datei liegt im Projekt. Gesucht wird das JDK über
+ * JAVA_HOME bzw. unter "C:\Program Files\Eclipse Adoptium", ASM im
+ * Bibliotheksordner von AeroMC (dort legen Fabric/Forge es ohnehin ab).
+ * Der Agent wird für Java 8 übersetzt, läuft also mit jeder Minecraft-Version.
+ *
+ * Aufruf: node scripts/build-agent.js
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const WURZEL = path.join(__dirname, '..');
+const ZIEL = path.join(WURZEL, 'src', 'assets', 'agent', 'aeromc-capes.jar');
+
+function findeJdk() {
+  const kandidaten = [];
+  if (process.env.JAVA_HOME) kandidaten.push(process.env.JAVA_HOME);
+  const adoptium = 'C:\\Program Files\\Eclipse Adoptium';
+  if (fs.existsSync(adoptium)) {
+    for (const d of fs.readdirSync(adoptium).filter((n) => /^jdk-/.test(n)).sort().reverse()) kandidaten.push(path.join(adoptium, d));
+  }
+  const jdk = kandidaten.find((d) => fs.existsSync(path.join(d, 'bin', process.platform === 'win32' ? 'javac.exe' : 'javac')));
+  if (!jdk) throw new Error('Kein JDK gefunden (JAVA_HOME setzen).');
+  return jdk;
+}
+
+function findeAsm(name) {
+  const basis = path.join(process.env.APPDATA || os.homedir(), 'aeromc', 'shared', 'libraries', 'org', 'ow2', 'asm', name);
+  if (!fs.existsSync(basis)) throw new Error(`ASM (${name}) nicht gefunden unter ${basis}`);
+  const versionen = fs.readdirSync(basis).filter((v) => /^9\./.test(v))
+    .sort((a, b) => b.split('.').map(Number).reduce((s, x, i) => s || x - (a.split('.').map(Number)[i] || 0), 0));
+  const datei = path.join(basis, versionen[0], `${name}-${versionen[0]}.jar`);
+  if (!fs.existsSync(datei)) throw new Error('ASM-Datei fehlt: ' + datei);
+  return datei;
+}
+
+function quellen(ordner) {
+  return fs.readdirSync(ordner, { withFileTypes: true }).flatMap((e) => {
+    const p = path.join(ordner, e.name);
+    return e.isDirectory() ? quellen(p) : (e.name.endsWith('.java') ? [p] : []);
+  });
+}
+
+const jdk = findeJdk();
+const javac = path.join(jdk, 'bin', 'javac');
+const java = path.join(jdk, 'bin', 'java');
+const asm = findeAsm('asm');
+const asmCommons = findeAsm('asm-commons');
+const asmTree = findeAsm('asm-tree');
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'aeromc-agent-'));
+const klassen = path.join(tmp, 'klassen');
+const werkzeug = path.join(tmp, 'werkzeug');
+console.log('JDK:', jdk);
+console.log('ASM:', asm);
+try {
+  execFileSync(javac, ['--release', '8', '-nowarn', '-encoding', 'UTF-8', '-cp', [asm, asmTree].join(path.delimiter), '-d', klassen,
+    ...quellen(path.join(WURZEL, 'agent', 'src'))], { stdio: 'inherit' });
+  execFileSync(javac, ['-encoding', 'UTF-8', '-cp', [asm, asmCommons].join(path.delimiter), '-d', werkzeug,
+    path.join(WURZEL, 'agent', 'tools', 'Shade.java')], { stdio: 'inherit' });
+  fs.mkdirSync(path.dirname(ZIEL), { recursive: true });
+  execFileSync(java, ['-cp', [werkzeug, asm, asmCommons].join(path.delimiter), 'Shade', ZIEL, klassen, asm, asmTree], { stdio: 'inherit' });
+  console.log(`Fertig: ${ZIEL} (${fs.statSync(ZIEL).size} Bytes)`);
+} finally {
+  fs.rmSync(tmp, { recursive: true, force: true });
+}

scripts/build-mod.js

@@ -0,0 +1,83 @@
+'use strict';
+
+/*
+ * build-mod.js – baut den Fabric/Quilt-Mod "AeroMC Umhänge" (dist/aeromc-umhaenge-fabric-<version>.jar)
+ * -------------------------------------------------------------------------------------------------
+ * Für Spieler, die NICHT den AeroMC Launcher nutzen. Der Mod greift wie der
+ * Umhang-Agent nur in Mojangs authlib ein (Mixin, ohne Namensumsetzung) – darum
+ * braucht es weder Gradle noch Fabric Loom, und eine Datei passt zu allen
+ * Minecraft-Versionen, die Fabric unterstützt. Übersetzt wird für Java 8.
+ *
+ * Gebraucht werden (nur beim Bauen) ein JDK sowie sponge-mixin und authlib aus
+ * dem Bibliotheksordner von AeroMC. Der Nachschlage-Code ist derselbe wie im
+ * Agenten (agent/src/de/aeromc/capes/Nachschlagen.java).
+ *
+ * Aufruf: node scripts/build-mod.js
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const WURZEL = path.join(__dirname, '..');
+const LIB = path.join(process.env.APPDATA || os.homedir(), 'aeromc', 'shared', 'libraries');
+const modInfo = JSON.parse(fs.readFileSync(path.join(WURZEL, 'mod', 'resources', 'fabric.mod.json'), 'utf8'));
+const ZIEL = path.join(WURZEL, 'dist', `aeromc-umhaenge-fabric-${modInfo.version}.jar`);
+
+function findeJdk() {
+  const kandidaten = [];
+  if (process.env.JAVA_HOME) kandidaten.push(process.env.JAVA_HOME);
+  const adoptium = 'C:\\Program Files\\Eclipse Adoptium';
+  if (fs.existsSync(adoptium)) {
+    for (const d of fs.readdirSync(adoptium).filter((n) => /^jdk-/.test(n)).sort().reverse()) kandidaten.push(path.join(adoptium, d));
+  }
+  const jdk = kandidaten.find((d) => fs.existsSync(path.join(d, 'bin', process.platform === 'win32' ? 'javac.exe' : 'javac')));
+  if (!jdk) throw new Error('Kein JDK gefunden (JAVA_HOME setzen).');
+  return jdk;
+}
+
+// neueste (oder mit aelteste=true älteste) Fassung einer Bibliothek im AeroMC-Bibliotheksordner
+function bibliothek(gruppe, name, aelteste = false) {
+  const basis = path.join(LIB, ...gruppe.split('.'), name);
+  if (!fs.existsSync(basis)) throw new Error(`${name} nicht gefunden unter ${basis}`);
+  const fassungen = fs.readdirSync(basis).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+  const v = aelteste ? fassungen[0] : fassungen.pop();
+  const datei = path.join(basis, v, `${name}-${v}.jar`);
+  if (!fs.existsSync(datei)) throw new Error('Datei fehlt: ' + datei);
+  return datei;
+}
+
+function quellen(ordner) {
+  return fs.readdirSync(ordner, { withFileTypes: true }).flatMap((e) => {
+    const p = path.join(ordner, e.name);
+    return e.isDirectory() ? quellen(p) : (e.name.endsWith('.java') ? [p] : []);
+  });
+}
+
+// authlib in der ältesten Fassung: SkinLaderMixin ruft getTextures(GameProfile, boolean) auf, das es nur bis authlib 4 gibt
+const jdk = findeJdk();
+const klassenpfad = [bibliothek('net.fabricmc', 'sponge-mixin'), bibliothek('com.mojang', 'authlib', true)].join(path.delimiter);
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'aeromc-mod-'));
+const inhalt = path.join(tmp, 'inhalt');
+const stubs = path.join(tmp, 'stubs');
+console.log('JDK:', jdk);
+try {
+  // Platzhalter für Minecraft-Klassen (nur zum Kompilieren, landen nicht im Jar)
+  execFileSync(path.join(jdk, 'bin', 'javac'), ['--release', '8', '-nowarn', '-encoding', 'UTF-8', '-d', stubs,
+    ...quellen(path.join(WURZEL, 'mod', 'stubs'))], { stdio: 'inherit' });
+  execFileSync(path.join(jdk, 'bin', 'javac'), ['--release', '8', '-nowarn', '-encoding', 'UTF-8', '-proc:none', '-cp', klassenpfad + path.delimiter + stubs, '-d', inhalt,
+    ...quellen(path.join(WURZEL, 'mod', 'src')),
+    path.join(WURZEL, 'agent', 'src', 'de', 'aeromc', 'capes', 'Nachschlagen.java')], { stdio: 'inherit' });
+  for (const datei of fs.readdirSync(path.join(WURZEL, 'mod', 'resources'))) {
+    fs.copyFileSync(path.join(WURZEL, 'mod', 'resources', datei), path.join(inhalt, datei));
+  }
+  fs.mkdirSync(path.join(inhalt, 'assets', 'aeromc-capes'), { recursive: true });
+  fs.copyFileSync(path.join(WURZEL, 'src', 'assets', 'logo.png'), path.join(inhalt, 'assets', 'aeromc-capes', 'icon.png'));
+  fs.mkdirSync(path.dirname(ZIEL), { recursive: true });
+  if (fs.existsSync(ZIEL)) fs.rmSync(ZIEL);
+  execFileSync(path.join(jdk, 'bin', 'jar'), ['--create', '--file', ZIEL, '-C', inhalt, '.'], { stdio: 'inherit' });
+  console.log(`Fertig: ${ZIEL} (${fs.statSync(ZIEL).size} Bytes)`);
+} finally {
+  fs.rmSync(tmp, { recursive: true, force: true });
+}

scripts/make-spieldesign.py

@@ -0,0 +1,712 @@
+"""
+make-spieldesign.py – erzeugt die Grafiken für den AeroMC-Look im Spiel
+=======================================================================
+Ausgabe nach src/assets/spieldesign/:
+
+  titel_alt.png / titel_neu.png     Titel-Logo (textures/gui/title/minecraft.png)
+                                    alt = bis 1.19.4 (zweigeteilt im 256×256-Atlas),
+                                    neu = ab 1.20 (ein Stück, 256×64)
+  edition_alt.png / edition_neu.png Untertitel "DEIN MINECRAFT ERLEBNIS" (edition.png)
+  ladelogo.png                      Ladebildschirm ab 1.16 als Vollbild (der Agent zieht
+                                    die Logo-Fläche auf Bildschirmgröße); im Format von
+                                    mojangstudios.png: linke Bildhälfte oben, rechte unten
+  ladelogo_alt.png                  Logo im Ladebildschirm 1.14/1.15 (ersetzt mojang.png)
+  panorama_0..5.png                 Hintergrund des Hauptmenüs (Würfelseiten)
+  pack.png, icon_<n>.rgba           Paket- und Fenstersymbol
+
+Eigene Bilder (optional) in scripts/spieldesign-quelle/:
+  hintergrund.png|jpg   Ladebildschirm-Hintergrund (am besten 16:9, z. B. 1920×1080)
+  panorama.png|jpg      Rundum-Panorama (360° × 180°, equirektangular, Seitenverhältnis 2:1)
+Fehlen sie, wird eine stilisierte Block-Landschaft in AeroMC-Blau gezeichnet.
+
+Alle Grafiken sind eigene Entwürfe – kein Mojang-Material.
+Aufruf: python scripts/make-spieldesign.py
+"""
+import math
+import os
+import random
+
+import numpy as np
+from PIL import Image, ImageChops, ImageDraw, ImageFilter, ImageFont
+
+WURZEL = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
+ZIEL = os.path.join(WURZEL, 'src', 'assets', 'spieldesign')
+QUELLE = os.path.join(WURZEL, 'scripts', 'spieldesign-quelle')
+LOGO = os.path.join(WURZEL, 'src', 'assets', 'logo.png')
+SCHRIFT = 'C:/Windows/Fonts/seguisb.ttf'
+NACHTBLAU = (10, 14, 26)        # Hintergrund des Ladebildschirms (muss zu Design.HINTERGRUND passen)
+KONTUR = (7, 14, 36)
+
+# ---------- Block-Buchstaben (7 Zeilen hoch) ----------
+GLYPHEN = {
+    'A': ['.####.', '##..##', '##..##', '######', '##..##', '##..##', '##..##'],
+    'E': ['######', '##....', '##....', '#####.', '##....', '##....', '######'],
+    'R': ['#####.', '##..##', '##..##', '#####.', '##.##.', '##..##', '##..##'],
+    'O': ['.####.', '##..##', '##..##', '##..##', '##..##', '##..##', '.####.'],
+    'M': ['##...##', '###.###', '#######', '##.#.##', '##...##', '##...##', '##...##'],
+    'C': ['.#####', '##....', '##....', '##....', '##....', '##....', '.#####'],
+}
+# kleine Pixelschrift für den Untertitel (5 Zeilen hoch)
+KLEIN = {
+    'D': ['###.', '#..#', '#..#', '#..#', '###.'], 'E': ['###', '#..', '##.', '#..', '###'],
+    'I': ['#', '#', '#', '#', '#'], 'N': ['#..#', '##.#', '#.##', '#..#', '#..#'],
+    'M': ['#...#', '##.##', '#.#.#', '#...#', '#...#'], 'C': ['.##', '#..', '#..', '#..', '.##'],
+    'R': ['##.', '#.#', '##.', '#.#', '#.#'], 'A': ['.#.', '#.#', '###', '#.#', '#.#'],
+    'F': ['###', '#..', '##.', '#..', '#..'], 'T': ['###', '.#.', '.#.', '.#.', '.#.'],
+    'L': ['#..', '#..', '#..', '#..', '###'], 'B': ['##.', '#.#', '##.', '#.#', '##.'],
+    'S': ['.##', '#..', '.#.', '..#', '##.'],
+}
+
+
+def raster(text, glyphen, abstand=1, wortabstand=3):
+    punkte, x = [], 0
+    for i, z in enumerate(text):
+        if z == ' ':
+            x += wortabstand
+            continue
+        g = glyphen[z]
+        for y, zeile in enumerate(g):
+            for dx, c in enumerate(zeile):
+                if c == '#':
+                    punkte.append((x + dx, y, i))
+        x += len(g[0]) + abstand
+    return punkte, x - abstand, len(next(iter(glyphen.values())))
+
+
+def verlauf(h, w, oben, unten):
+    t = np.linspace(0, 1, h)[:, None, None]
+    return np.broadcast_to(np.array(oben, float) * (1 - t) + np.array(unten, float) * t, (h, w, 3)).copy()
+
+
+def rgba(arr, maske):
+    a = np.dstack([np.clip(arr, 0, 255), maske]).astype(np.uint8)
+    return Image.fromarray(a, 'RGBA')
+
+
+# ---------- Schriftzug ----------
+
+def schriftzug(b, flach=False):
+    """'AERO MC' aus Blöcken der Größe b (Pixel): Vorderseite, Tiefe nach unten, Kontur."""
+    punkte, breite, hoehe = raster('AERO MC', GLYPHEN, 1, 2)
+    tiefe = 0 if flach else max(2, int(b * 0.55))
+    k = 0 if flach else max(2, b // 5)
+    W, H = breite * b + 2 * k, hoehe * b + tiefe + 2 * k
+    front = np.zeros((H, W), bool)
+    blau = np.zeros((H, W), bool)
+    kante = np.zeros((H, W), float)
+    belegt = {(x, y) for x, y, _ in punkte}
+    rnd = np.random.RandomState(7)
+    rauschen = np.zeros((H, W))
+    zell = max(1, b // 4)
+    for bx, by, i in punkte:
+        x0, y0 = k + bx * b, k + by * b
+        front[y0:y0 + b, x0:x0 + b] = True
+        if i >= 5:
+            blau[y0:y0 + b, x0:x0 + b] = True
+        # Stein-Struktur in kleinen Zellen
+        for yy in range(0, b, zell):
+            for xx in range(0, b, zell):
+                rauschen[y0 + yy:y0 + yy + zell, x0 + xx:x0 + xx + zell] = rnd.randint(-9, 6)
+        if (bx, by - 1) not in belegt:
+            kante[y0:y0 + max(1, b // 6), x0:x0 + b] = 34          # helle Oberkante
+        if (bx + 1, by) not in belegt:
+            kante[y0:y0 + b, x0 + b - max(1, b // 7):x0 + b] -= 26  # dunklere rechte Kante
+    hell = verlauf(H, W, (255, 255, 255), (176, 190, 214))
+    mc = verlauf(H, W, (170, 236, 255), (34, 108, 232))
+    farbe = np.where(blau[..., None], mc, hell) + (rauschen + kante)[..., None]
+    if flach:
+        return rgba(farbe, front * 255)
+    seite = np.zeros((H, W), bool)
+    for t in range(1, tiefe + 1):
+        seite[t:, :] |= front[:-t, :]
+    seite &= ~front
+    blau_seite = np.zeros((H, W), bool)
+    for t in range(1, tiefe + 1):
+        blau_seite[t:, :] |= blau[:-t, :]
+    seite_farbe = np.where(blau_seite[..., None], verlauf(H, W, (30, 84, 190), (14, 44, 120)),
+                           verlauf(H, W, (112, 126, 156), (66, 78, 104)))
+    alles = Image.fromarray(((front | seite) * 255).astype(np.uint8))
+    kontur = np.array(alles.filter(ImageFilter.MaxFilter(2 * k + 1))) > 0
+    bild = np.zeros((H, W, 3))
+    bild[kontur] = KONTUR
+    bild[seite] = seite_farbe[seite]
+    bild[front] = farbe[front]
+    return rgba(bild, kontur * 255)
+
+
+def pyramide(w, h):
+    """Blaue Pyramide (linke Seite hell, rechte dunkel, leuchtender Grat)."""
+    w, h = int(w), int(h)
+    links = Image.new('L', (w, h), 0)
+    rechts = Image.new('L', (w, h), 0)
+    spitze, mitte = (w * 0.5, 0), (w * 0.56, h)
+    ImageDraw.Draw(links).polygon([spitze, (0, h), mitte], fill=255)
+    ImageDraw.Draw(rechts).polygon([spitze, mitte, (w, h)], fill=255)
+    hell = verlauf(h, w, (150, 232, 255), (40, 126, 236))
+    dunkel = verlauf(h, w, (52, 130, 236), (14, 48, 140))
+    l, r = np.array(links) > 0, np.array(rechts) > 0
+    bild = np.zeros((h, w, 3))
+    bild[l] = hell[l]
+    bild[r] = dunkel[r]
+    img = rgba(bild, np.maximum(np.array(links), np.array(rechts)))
+    d = ImageDraw.Draw(img)
+    d.line([spitze, mitte], fill=(215, 248, 255, 255), width=max(2, w // 70))
+    d.line([spitze, (0, h)], fill=(120, 215, 255, 255), width=max(1, w // 140))
+    return img
+
+
+def leuchten(bild, radius, farbe=(70, 190, 255), staerke=0.75):
+    a = bild.split()[3].filter(ImageFilter.MaxFilter(3)).filter(ImageFilter.GaussianBlur(radius))
+    a = a.point(lambda v: int(v * staerke))
+    g = Image.new('RGBA', bild.size, farbe + (0,))
+    g.putalpha(a)
+    return g
+
+
+def logo(b, mit_leuchten=True):
+    """Pyramide hinter dem Schriftzug, wie im Entwurf. Rückgabe: Bild, Unterkante des Schriftzugs."""
+    text = schriftzug(b)
+    pw, ph = text.width * 0.46, text.height * 1.55
+    pyr = pyramide(pw, ph)
+    oben = int(ph - text.height * 0.62)                    # so weit ragt die Pyramide über den Text
+    rand = int(b * 1.2) if mit_leuchten else 0
+    W, H = text.width + 2 * rand, oben + text.height + 2 * rand
+    bild = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    px = rand + (text.width - pyr.width) // 2 + int(text.width * 0.03)
+    schicht = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    schicht.alpha_composite(pyr, (px, rand))
+    schicht.alpha_composite(text, (rand, rand + oben))
+    if mit_leuchten:
+        bild.alpha_composite(leuchten(schicht, b * 0.9))
+    bild.alpha_composite(schicht)
+    return bild, rand + oben + text.height
+
+
+def einpassen(bild, w, h):
+    f = min(w / bild.width, h / bild.height, 1.0)
+    return bild.resize((max(1, int(bild.width * f)), max(1, int(bild.height * f))), Image.LANCZOS) if f < 1 else bild
+
+
+# ---------- Titel-Texturen ----------
+
+def titel_art():
+    """Pyramide, Schriftzug und Untertitel zusammen (Titel im Hauptmenü)."""
+    art, unterkante = logo(15)
+    unter, _ = untertitel_bild(5)
+    bild = Image.new('RGBA', (max(art.width, unter.width), unterkante + 8 + unter.height), (0, 0, 0, 0))
+    bild.alpha_composite(art, ((bild.width - art.width) // 2, 0))
+    bild.alpha_composite(unter, ((bild.width - unter.width) // 2, unterkante + 8))
+    return bild
+
+
+def titel(alt):
+    """
+    Der Agent erweitert den gezeichneten Streifen auf 64 Punkte Höhe (sonst 44).
+    neu (ab 1.20): 256×64-Textur, ganz genutzt.
+    alt (bis 1.19.4): Stücke (0,0,155,64) und (0,65,155,64) im 256×256-Atlas,
+    sichtbare Mitte bei x=137 des 310 breiten Streifens.
+    """
+    art = einpassen(titel_art(), (274 if alt else 256) * 4 - 8, 64 * 4)
+    if not alt:
+        t = Image.new('RGBA', (1024, 256), (0, 0, 0, 0))
+        t.alpha_composite(art, ((1024 - art.width) // 2, 256 - art.height))
+        return t
+    streifen = Image.new('RGBA', (310 * 4, 64 * 4), (0, 0, 0, 0))
+    streifen.alpha_composite(art, (137 * 4 - art.width // 2, 256 - art.height))
+    t = Image.new('RGBA', (1024, 1024), (0, 0, 0, 0))
+    t.alpha_composite(streifen.crop((0, 0, 620, 256)), (0, 0))
+    t.alpha_composite(streifen.crop((620, 0, 1240, 256)), (0, 65 * 4))
+    return t
+
+
+def untertitel_bild(skala, farbe=(236, 244, 255), schatten=(8, 16, 40)):
+    punkte, breite, hoehe = raster('DEIN MINECRAFT ERLEBNIS', KLEIN, 1, 3)
+    img = Image.new('RGBA', ((breite + 1) * skala, (hoehe + 1) * skala), (0, 0, 0, 0))
+    d = ImageDraw.Draw(img)
+    for dx, dy, f in ((1, 1, schatten), (0, 0, farbe)):
+        for x, y, _ in punkte:
+            d.rectangle(((x + dx) * skala, (y + dy) * skala, (x + dx + 1) * skala - 1, (y + dy + 1) * skala - 1), fill=f + (255,))
+    return img, breite
+
+
+def edition(breite_max):
+    img, breite = untertitel_bild(4)
+    if breite + 1 > breite_max:
+        raise SystemExit(f'Untertitel zu breit: {breite} > {breite_max}')
+    t = Image.new('RGBA', (512, 64), (0, 0, 0, 0))
+    t.alpha_composite(img, ((breite_max * 4 - img.width) // 2, (56 - img.height) // 2))
+    return t
+
+
+# ---------- stilisierte Block-Landschaft (Abendstimmung am Bergsee) ----------
+# Eine Szene, zwei Ansichten: als Rundum-Panorama (Menü) und als flacher
+# Ausschnitt nach vorne (Ladebildschirm). Gleicher Zufallswert -> gleiche Berge.
+
+def _mix(a, b, t):
+    return np.array(a, np.float32) * (1 - t) + np.array(b, np.float32) * t
+
+
+def _profil(phi, seed, schritt_rad):
+    """periodisches Höhenprofil 0..1, blockig gestuft"""
+    r = random.Random(seed)
+    stufe = np.floor(phi / schritt_rad) * schritt_rad + schritt_rad / 2
+    werte = np.zeros_like(phi)
+    for k in range(1, 16):
+        werte += r.uniform(0.25, 1.0) / k ** 1.05 * np.sin(k * stufe + r.uniform(0, 6.3))
+    return (werte + 2.2) / 4.4
+
+
+def szene(W, H, horizont, start, spanne, seed=2026):
+    rnd = random.Random(seed)
+    ppd = W / math.degrees(spanne)                     # Pixel je Grad
+    blk = max(4, int(round(ppd * 0.9)))                # Blockgröße der Silhouetten
+    schritt = math.radians(blk / ppd)                  # ein Block als Winkel
+    phi = (start + np.arange(W, dtype=np.float32) / W * spanne).astype(np.float32)
+    y = np.arange(H, dtype=np.float32)[:, None]
+    grad = (horizont - y) / ppd                        # Höhe über dem Horizont in Grad
+
+    sonne = math.pi + 0.66
+    dphi = np.angle(np.exp(1j * (phi - sonne))).astype(np.float32)[None, :]
+
+    # Himmel: Blau oben, hell am Horizont, warmer Abendschein um die Sonne
+    t = np.clip(grad / 75, 0, 1)[..., None]
+    himmel = np.where(t < 0.3, _mix((168, 202, 238), (66, 124, 210), t / 0.3), _mix((66, 124, 210), (16, 36, 96), (t - 0.3) / 0.7))
+    warm = (np.exp(-dphi ** 2 / 0.55) * np.exp(-(np.clip(grad, 0, None) / 14) ** 2))[..., None]
+    himmel = himmel * (1 - 0.8 * warm) + np.array([255, 178, 120], np.float32) * 0.8 * warm
+    bild = np.broadcast_to(himmel, (H, W, 3)).astype(np.float32).copy()
+
+    def maske_hoehe(h_grad):
+        return (grad >= 0) & (grad <= h_grad[None, :])
+
+    def stufen(h_grad):
+        return np.floor(h_grad * ppd / blk) * blk / ppd
+
+    # Sonne (eckig, wie im Spiel) mit Schein
+    s_x = (sonne - start) / spanne * W
+    s_y = horizont - 12 * ppd
+    s_r = 2.6 * ppd
+    rr = np.sqrt(((np.arange(W) - s_x) / ppd)[None, :] ** 2 + ((y - s_y) / ppd) ** 2)
+    bild += (np.exp(-(rr / 6) ** 2) * 0.55)[..., None] * np.array([255, 210, 150], np.float32)
+    quadrat = (np.abs(np.arange(W) - s_x)[None, :] < s_r) & (np.abs(y - s_y) < s_r)
+    bild[quadrat] = (255, 244, 205)
+
+    # Wolken (flach und blockig)
+    wolken = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    d = ImageDraw.Draw(wolken)
+    for _ in range(18):
+        p = rnd.uniform(0, 2 * math.pi)
+        for versatz in (-2 * math.pi, 0, 2 * math.pi):
+            cx = (p + versatz - start) / spanne * W
+            if -W * 0.2 < cx < W * 1.2:
+                break
+        else:
+            continue
+        cy = horizont - rnd.uniform(20, 42) * ppd
+        s = blk
+        nah_sonne = abs(math.atan2(math.sin(p - sonne), math.cos(p - sonne))) < 0.7
+        farbe = (255, 222, 196) if nah_sonne else (232, 240, 252)
+        for _ in range(rnd.randint(2, 4)):
+            w, h = rnd.randint(6, 16) * s, rnd.randint(1, 2) * s
+            ox, oy = rnd.randint(-4, 4) * s, rnd.randint(-1, 0) * s
+            d.rectangle((cx + ox, cy + oy, cx + ox + w, cy + oy + h), fill=farbe + (170,))
+            d.rectangle((cx + ox, cy + oy + h - max(2, s // 3), cx + ox + w, cy + oy + h), fill=tuple(int(c * 0.82) for c in farbe) + (170,))
+
+    # ferne Berge mit Schnee
+    h_fern = stufen(6 + 22 * _profil(phi, seed + 1, schritt))
+    m = maske_hoehe(h_fern)
+    tb = np.clip(grad / 28, 0, 1)[..., None]
+    fels = _mix((46, 66, 112), (96, 118, 168), tb)
+    schnee = (grad > h_fern[None, :] - 3 * blk / ppd) & (h_fern[None, :] > 15)
+    fels = np.where(schnee[..., None], np.array([236, 242, 255], np.float32), fels)
+    sonnenseite = (np.exp(-dphi ** 2 / 0.6))[..., None] * 0.35
+    fels = fels * (1 - sonnenseite) + np.array([255, 190, 150], np.float32) * sonnenseite
+    bild[m] = np.broadcast_to(fels, bild.shape)[m]
+    # bewaldete Hügel
+    h_huegel = stufen(2 + 7 * _profil(phi, seed + 2, schritt))
+    m = maske_hoehe(h_huegel)
+    huegel = _mix((26, 70, 58), (44, 98, 74), np.clip(grad / 7, 0, 1)[..., None])
+    bild[m] = np.broadcast_to(huegel, bild.shape)[m]
+
+    img = Image.fromarray(np.clip(bild, 0, 255).astype(np.uint8), 'RGB').convert('RGBA')
+    img.alpha_composite(wolken)
+    # Fichten am Ufer
+    wald = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    d = ImageDraw.Draw(wald)
+    s = max(3, blk // 2)
+    for _ in range(int(W / s * 0.55)):
+        x = rnd.randrange(W)
+        hoehe = rnd.randint(6, 13)
+        dunkel = rnd.choice(((14, 44, 34), (18, 52, 40), (12, 38, 32)))
+        d.rectangle((x - s // 2, horizont - 2 * s, x + s // 2, horizont), fill=(40, 28, 20, 255))
+        for stufe in range(hoehe):
+            breite = max(0, (hoehe - stufe) // 2 - (stufe % 2))
+            y0 = horizont - (stufe + 2) * s
+            d.rectangle((x - breite * s - s // 2, y0, x + breite * s + s // 2, y0 + s), fill=dunkel + (255,))
+            d.rectangle((x + breite * s - s // 2, y0, x + breite * s + s // 2, y0 + s), fill=tuple(c + 14 for c in dunkel) + (255,))
+    img.alpha_composite(wald)
+    bild = np.array(img.convert('RGB'), np.float32)
+
+    # See: Spiegelung, nach unten dunkler, Wellen und Sonnenglitzern
+    unten = H - horizont
+    zeilen = np.clip(horizont - 1 - np.arange(unten), 0, H - 1)
+    spiegel = bild[zeilen]
+    tiefe = np.linspace(0, 1, unten, dtype=np.float32)[:, None, None]
+    wellen = ((np.sin(np.arange(unten, dtype=np.float32)[:, None] * (0.55 / max(1, ppd / 10)) + np.sin(phi[None, :] * 37) * 1.6) > 0.86) * 14)[..., None]
+    see = spiegel * (0.62 - 0.32 * tiefe) + np.array([10, 30, 62], np.float32) * (0.45 + 0.55 * tiefe) + wellen * np.array([0.5, 0.8, 1.0], np.float32)
+    glitzer = (np.exp(-(dphi[0] / 0.07) ** 2)[None, :] * (np.sin(np.arange(unten)[:, None] * 1.7 + phi[None, :] * 900) > 0.6) * np.exp(-tiefe[..., 0] * 3))[..., None]
+    see += glitzer * np.array([255, 200, 140], np.float32) * 0.8
+    bild[horizont:] = see
+
+    # leuchtende Pixel (AeroMC)
+    img = Image.fromarray(np.clip(bild, 0, 255).astype(np.uint8), 'RGB').convert('RGBA')
+    pixel = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    d = ImageDraw.Draw(pixel)
+    for _ in range(int(W / 60)):
+        x = rnd.randrange(W)
+        yy = horizont - rnd.uniform(-8, 30) * ppd
+        g = rnd.choice((0.6, 0.8, 1.0, 1.3)) * ppd
+        d.rectangle((x, yy, x + g, yy + g), fill=(90, 210, 255, rnd.randint(150, 235)))
+    img.alpha_composite(leuchten(pixel, max(4, ppd * 0.8), (60, 170, 255), 1.0))
+    img.alpha_composite(pixel)
+    return img.convert('RGB')
+
+
+def landschaft(W=4096, H=2048):
+    """Rundum-Panorama (equirektangular): Spalte W/2 = Blick nach vorne."""
+    return szene(W, H, H // 2, 0.0, 2 * math.pi)
+
+
+def landschaft_flach(W=1920, H=1080):
+    """Ausschnitt nach vorne (ca. 110°) für den Ladebildschirm."""
+    spanne = math.radians(110)
+    return szene(W, H, int(H * 0.6), math.pi - spanne / 2, spanne)
+
+
+def wuerfelseiten(equi, groesse=1024):
+    """Equirektangulares Panorama -> 6 Würfelseiten (0 vorne, 1 rechts, 2 hinten, 3 links, 4 oben, 5 unten)."""
+    q = np.array(equi.convert('RGB'), float)
+    H, W = q.shape[:2]
+    a = (np.arange(groesse) + 0.5) / groesse * 2 - 1
+    u, v = np.meshgrid(a, a)
+    eins = np.ones_like(u)
+    richtungen = [(u, -v, eins), (eins, -v, -u), (-u, -v, -eins), (-eins, -v, u), (u, eins, v), (u, -eins, -v)]
+    seiten = []
+    for dx, dy, dz in richtungen:
+        lon = np.arctan2(dx, dz)
+        lat = np.arctan2(dy, np.sqrt(dx * dx + dz * dz))
+        x = (lon / (2 * math.pi) + 0.5) * W - 0.5
+        y = (0.5 - lat / math.pi) * H - 0.5
+        x0 = np.floor(x).astype(int); y0 = np.clip(np.floor(y).astype(int), 0, H - 2)
+        fx, fy = (x - x0)[..., None], np.clip(y - y0, 0, 1)[..., None]
+        x1 = (x0 + 1) % W; x0 %= W
+        p = (q[y0, x0] * (1 - fx) * (1 - fy) + q[y0, x1] * fx * (1 - fy) + q[y0 + 1, x0] * (1 - fx) * fy + q[y0 + 1, x1] * fx * fy)
+        seiten.append(Image.fromarray(np.clip(p, 0, 255).astype(np.uint8), 'RGB'))
+    return seiten
+
+
+def seiten_aus_bild(bild, g=1024):
+    """
+    Aus einem flachen Bild (16:9) einen nahtlosen Würfel:
+      – vorne = linke Bildhälfte, rechts = rechte Hälfte, hinten/links = dieselben
+        gespiegelt, so stoßen alle senkrechten Kanten passend aneinander;
+      – oben/unten: die vier Seiten werden in ein Rundum-Panorama umgerechnet, dort
+        nach unten (Wasser) bzw. oben (Himmel) gespiegelt fortgesetzt und weich
+        auslaufen gelassen, daraus dann die obere und untere Würfelseite gerechnet.
+        So gehen die Kanten nahtlos über – keine einfarbigen Flächen.
+    """
+    b = bild.convert('RGB').resize((2 * g, g), Image.LANCZOS)
+    vorne, rechts = b.crop((0, 0, g, g)), b.crop((g, 0, 2 * g, g))
+    hinten, links = rechts.transpose(Image.FLIP_LEFT_RIGHT), vorne.transpose(Image.FLIP_LEFT_RIGHT)
+    seiten = [np.array(s, np.float32) for s in (vorne, rechts, hinten, links)]
+
+    # 1) Seiten -> equirektangulares Panorama (oben/unten zunächst leer)
+    W, H = 4 * g, 2 * g
+    lon = ((np.arange(W) + 0.5) / W - 0.5) * 2 * math.pi
+    lat = (0.5 - (np.arange(H) + 0.5) / H) * math.pi
+    LON, LAT = np.meshgrid(lon, lat)
+    dx, dy, dz = np.cos(LAT) * np.sin(LON), np.sin(LAT), np.cos(LAT) * np.cos(LON)
+    equi = np.zeros((H, W, 3), np.float32)
+    gueltig = np.zeros((H, W), bool)
+    seitlich = np.abs(dy) < np.maximum(np.abs(dx), np.abs(dz))
+    # (Maske, s, u, v) passend zu wuerfelseiten(): vorne (u,-v,1), rechts (1,-v,-u), hinten (-u,-v,-1), links (-1,-v,u)
+    faelle = [
+        (seitlich & (dz >= np.abs(dx)), dz, dx, -dy),
+        (seitlich & (dx > np.abs(dz)), dx, -dz, -dy),
+        (seitlich & (-dz >= np.abs(dx)), -dz, -dx, -dy),
+        (seitlich & (-dx > np.abs(dz)), -dx, dz, -dy),
+    ]
+    for (maske, s, u, v), seite in zip(faelle, seiten):
+        su, sv = u[maske] / s[maske], v[maske] / s[maske]
+        px = np.clip(((su + 1) / 2 * g).astype(int), 0, g - 1)
+        py = np.clip(((sv + 1) / 2 * g).astype(int), 0, g - 1)
+        equi[maske] = seite[py, px]
+        gueltig |= maske
+
+    # 2) Lücken spiegeln: unten das Wasser (dunkler werdend), oben der Himmel
+    zeilen = np.arange(H)[:, None]
+    unterste = np.where(gueltig.any(0), H - 1 - np.argmax(gueltig[::-1], axis=0), H // 2)
+    oberste = np.where(gueltig.any(0), np.argmax(gueltig, axis=0), H // 2)
+    spalten = np.arange(W)[None, :]
+    unten = zeilen > unterste[None, :]
+    oben = zeilen < oberste[None, :]
+    quelle_unten = np.clip(2 * unterste[None, :] - zeilen, oberste[None, :], H - 1)
+    quelle_oben = np.broadcast_to(np.clip(oberste[None, :] + 2, 0, H - 1), (H, W))   # Himmel: oberste Zeile nach oben verlängern
+    gespiegelt = equi.copy()
+    gespiegelt[unten] = equi[quelle_unten, np.broadcast_to(spalten, (H, W))][unten]
+    gespiegelt[oben] = equi[quelle_oben, np.broadcast_to(spalten, (H, W))][oben]
+    # zum Pol hin weich in eine ruhige Farbe auslaufen lassen (keine Kreuznaht im Würfel)
+    abstand_unten = np.clip((zeilen - unterste[None, :]) / (H * 0.34), 0, 1)[..., None] ** 1.3
+    abstand_oben = np.clip((oberste[None, :] - zeilen) / (H * 0.34), 0, 1)[..., None] ** 1.3
+    # Wasserfarbe aus der Bildmitte (am unteren Rand stehen Pflanzen), Himmel vom oberen Rand
+    roh = np.array(b, np.float32)
+    wasser = np.median(roh[int(g * 0.62):int(g * 0.82), int(g * 0.5):int(g * 1.5)].reshape(-1, 3), axis=0)
+    himmel = equi[np.clip(oberste + 4, 0, H - 1), np.arange(W)].mean(0)
+    gespiegelt = np.where(unten[..., None], gespiegelt * (1 - abstand_unten) * 0.9 + wasser * 0.8 * abstand_unten, gespiegelt)
+    gespiegelt = np.where(oben[..., None], gespiegelt * (1 - abstand_oben) + himmel * abstand_oben, gespiegelt)
+    bild_equi = Image.fromarray(np.clip(gespiegelt, 0, 255).astype(np.uint8), 'RGB')
+    weich = bild_equi.filter(ImageFilter.GaussianBlur(16))
+    maske_luecke = Image.fromarray(((unten | oben) * 255).astype(np.uint8)).filter(ImageFilter.GaussianBlur(6))
+    bild_equi = Image.composite(weich, bild_equi, maske_luecke)
+
+    # 3) daraus oben/unten; die vier Seiten bleiben die scharfen Originale
+    neu = wuerfelseiten(bild_equi, g)
+    return [vorne, rechts, hinten, links, neu[4], neu[5]]
+
+
+def quelle(name):
+    for endung in ('png', 'jpg', 'jpeg', 'webp'):
+        p = os.path.join(QUELLE, f'{name}.{endung}')
+        if os.path.exists(p):
+            return Image.open(p).convert('RGB')
+    return None
+
+
+def fuellen(bild, w, h):
+    f = max(w / bild.width, h / bild.height)
+    b = bild.resize((int(bild.width * f + 0.5), int(bild.height * f + 0.5)), Image.LANCZOS)
+    x, y = (b.width - w) // 2, (b.height - h) // 2
+    return b.crop((x, y, x + w, y + h))
+
+
+# ---------- Ladebildschirm (Vollbild) ----------
+
+def ladebild(mit_text=True):
+    W, H = 1920, 1080
+    eigenes = quelle('hintergrund')
+    if eigenes is not None:
+        grund = fuellen(eigenes, W, H)
+    else:  # gleiche Landschaft wie im Menü, als Blick nach vorne
+        grund = landschaft_flach(W, H)
+    bild = grund.convert('RGBA')
+    # leichte Abdunklung zur Mitte und unten, damit Logo und Balken lesbar sind
+    schatten = Image.new('L', (W, H), 0)
+    ImageDraw.Draw(schatten).ellipse((W * 0.18, H * 0.12, W * 0.82, H * 0.72), fill=95)
+    schatten = schatten.filter(ImageFilter.GaussianBlur(120))
+    unten = Image.fromarray((np.clip((np.arange(H) - H * 0.62) / (H * 0.38), 0, 1) * 120).astype(np.uint8)[:, None].repeat(W, 1))
+    dunkel = Image.new('RGBA', (W, H), (4, 8, 20, 0))
+    dunkel.putalpha(ImageChops.lighter(schatten, unten))
+    bild.alpha_composite(dunkel)
+    art, _ = logo(30)
+    art = einpassen(art, int(W * 0.62), int(H * 0.56))
+    lx, ly = (W - art.width) // 2, int(H * 0.40 - art.height / 2)
+    bild.alpha_composite(art, (lx, ly))
+    unter, _ = untertitel_bild(6)
+    bild.alpha_composite(unter, ((W - unter.width) // 2, ly + art.height + 6))
+    if not mit_text:   # Neustart-Bildschirm des Launchers setzt Text und Balken selbst darüber
+        return bild.convert('RGB')
+    # "Wird geladen …" unter dem Balken (Minecraft zeichnet den Balken bei 83,25 % der Höhe)
+    schrift = ImageFont.truetype(SCHRIFT, 34)
+    text = 'Wird geladen …'
+    tb = ImageDraw.Draw(bild).textbbox((0, 0), text, font=schrift)
+    tw, th = tb[2] - tb[0], tb[3] - tb[1]
+    kasten = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    kx, ky = (W - tw) // 2, int(H * 0.885)
+    ImageDraw.Draw(kasten).rounded_rectangle((kx - 26, ky - 14, kx + tw + 26, ky + th + 22), radius=10, fill=(6, 12, 28, 175))
+    bild.alpha_composite(kasten)
+    ImageDraw.Draw(bild).text((kx - tb[0], ky - tb[1] + 2), text, font=schrift, fill=(236, 244, 255, 255))
+    return bild.convert('RGB')
+
+
+def als_logotextur(bild):
+    """
+    Minecraft zeichnet das Logo additiv auf den Hintergrund und teilt es: linke
+    Hälfte aus der oberen Texturhälfte, rechte aus der unteren. Darum: Nachtblau
+    abziehen (wird beim Zeichnen wieder addiert) und die Hälften gestreckt stapeln.
+    """
+    a = np.clip(np.array(bild, float) - np.array(NACHTBLAU, float), 0, 255).astype(np.uint8)
+    b = Image.fromarray(a, 'RGB')
+    w, h = b.size
+    t = Image.new('RGB', (2048, 2048))
+    t.paste(b.crop((0, 0, w // 2, h)).resize((2048, 1024), Image.LANCZOS), (0, 0))
+    t.paste(b.crop((w // 2, 0, w, h)).resize((2048, 1024), Image.LANCZOS), (0, 1024))
+    return t.convert('RGBA')
+
+
+# ---------- Knöpfe und Symbole (wie im Entwurf) ----------
+
+SYMBOL_ZEICHEN = ['', '', '', '', '', '']   # Spitzhacke, Personen, Globus, Zahnrad, Ein/Aus, Puzzle (Mods)
+
+
+def knopf(hell, f):
+    """Knopf 200×20 Punkte in f-facher Auflösung: dunkles Schiefer bzw. leuchtendes Blau."""
+    w, h = 200 * f, 20 * f
+    if hell:
+        oben, unten, rand, licht = (64, 166, 248), (20, 92, 200), (130, 232, 255), (170, 225, 255)
+    else:
+        oben, unten, rand, licht = (46, 56, 74), (24, 30, 42), (124, 142, 172), (78, 92, 118)
+    a = verlauf(h, w, oben, unten)
+    bild = rgba(a, np.full((h, w), 255, np.uint8))
+    d = ImageDraw.Draw(bild)
+    s = max(1, f // 2)
+    d.rectangle((0, 0, w - 1, h - 1), outline=(6, 10, 20, 255), width=s)            # dunkle Außenkante
+    d.rectangle((s, s, w - 1 - s, h - 1 - s), outline=rand + (255,), width=s)          # heller Rand
+    d.line((2 * s, 2 * s, w - 1 - 2 * s, 2 * s), fill=licht + (255,), width=s)       # Lichtkante oben
+    for x0, y0 in ((0, 0), (w - s, 0), (0, h - s), (w - s, h - s)):                   # Ecken leicht abgerundet
+        d.rectangle((x0, y0, x0 + s - 1, y0 + s - 1), fill=(0, 0, 0, 0))
+    return bild
+
+
+def puzzle(farbe=(238, 246, 255, 255), groesse=64):
+    """Puzzleteil (Symbol für Mods)."""
+    b = Image.new('RGBA', (64, 64), (0, 0, 0, 0))
+    d = ImageDraw.Draw(b)
+    d.rounded_rectangle((8, 18, 46, 56), radius=5, fill=farbe)
+    d.ellipse((19, 4, 35, 22), fill=farbe)          # Nase oben
+    d.ellipse((42, 29, 60, 45), fill=farbe)         # Nase rechts
+    d.ellipse((4, 29, 18, 43), fill=(0, 0, 0, 0))   # Kerbe links
+    return b if groesse == 64 else b.resize((groesse, groesse), Image.LANCZOS)
+
+
+def symbole():
+    """6 Symbole, je 16×16 (aus 64×64 verkleinert), weiß – als Schriftzeichen."""
+    groesse, f = 64, 4
+    leinwand = Image.new('RGBA', (16 * 6, 16), (0, 0, 0, 0))
+    farbe = (238, 246, 255, 255)
+
+    def neu():
+        return Image.new('RGBA', (groesse, groesse), (0, 0, 0, 0))
+
+    bilder = []
+    b = neu(); d = ImageDraw.Draw(b)                                   # Spitzhacke: aufrecht zeichnen, dann kippen
+    d.line((32, 16, 32, 62), fill=farbe, width=10)
+    d.arc((2, 12, 62, 56), 198, 342, fill=farbe, width=12)
+    d.polygon([(4, 30), (0, 40), (10, 34)], fill=farbe); d.polygon([(60, 30), (64, 40), (54, 34)], fill=farbe)
+    bilder.append(b.rotate(-40, resample=Image.BICUBIC))
+    b = neu(); d = ImageDraw.Draw(b)                                   # zwei Personen
+    d.ellipse((30, 8, 50, 28), fill=farbe); d.pieslice((22, 30, 58, 70), 180, 360, fill=farbe)
+    d.ellipse((10, 14, 28, 32), fill=farbe); d.pieslice((2, 34, 36, 68), 180, 360, fill=farbe)
+    bilder.append(b)
+    b = neu(); d = ImageDraw.Draw(b)                                   # Globus
+    d.ellipse((4, 4, 60, 60), outline=farbe, width=8)
+    d.ellipse((20, 4, 44, 60), outline=farbe, width=7)
+    d.line((4, 32, 60, 32), fill=farbe, width=7)
+    d.arc((10, -10, 54, 26), 30, 150, fill=farbe, width=3); d.arc((10, 38, 54, 74), 210, 330, fill=farbe, width=3)
+    bilder.append(b)
+    b = neu(); d = ImageDraw.Draw(b)                                   # Zahnrad
+    for k in range(8):
+        w = k * math.pi / 4
+        cx, cy = 32 + math.cos(w) * 23, 32 + math.sin(w) * 23
+        pts = [(cx + math.cos(w + p) * 7, cy + math.sin(w + p) * 7) for p in (0.8, 2.35, 3.9, 5.5)]
+        d.polygon(pts, fill=farbe)
+    d.ellipse((12, 12, 52, 52), fill=farbe)
+    d.ellipse((26, 26, 38, 38), fill=(0, 0, 0, 0))
+    bilder.append(b)
+    b = neu(); d = ImageDraw.Draw(b)                                   # Ein/Aus
+    d.arc((6, 8, 58, 60), -60, 240, fill=farbe, width=10)
+    d.line((32, 2, 32, 30), fill=farbe, width=10)
+    bilder.append(b)
+    bilder.append(puzzle(farbe))
+    for i, b in enumerate(bilder):
+        leinwand.alpha_composite(b.resize((16, 16), Image.LANCZOS), (16 * i, 0))
+    return leinwand
+
+
+def sprachdateien():
+    """Symbole vor die Beschriftungen der Menüknöpfe setzen (de_de und en_us)."""
+    import json
+    sp, mp, rl, op, qu, md = SYMBOL_ZEICHEN
+    texte = {
+        'de_de': {'menu.singleplayer': 'Einzelspieler', 'menu.multiplayer': 'Mehrspieler', 'menu.online': 'Minecraft Realms',
+                  'menu.options': 'Optionen …', 'menu.quit': 'Spiel beenden'},
+        'en_us': {'menu.singleplayer': 'Singleplayer', 'menu.multiplayer': 'Multiplayer', 'menu.online': 'Minecraft Realms',
+                  'menu.options': 'Options...', 'menu.quit': 'Quit Game'},
+    }
+    zeichen = {'menu.singleplayer': sp, 'menu.multiplayer': mp, 'menu.online': rl, 'menu.options': op, 'menu.quit': qu}
+    aus = {}
+    for sprache, t in texte.items():
+        aus[sprache] = json.dumps({k: zeichen[k] + '  ' + v for k, v in t.items()}, ensure_ascii=True, indent=2)
+    mods = {
+        'de_de': {'menu.sendFeedback': md + '  Mods verwalten …', 'menu.feedback': md + '  Mods & Feedback …'},
+        'en_us': {'menu.sendFeedback': md + '  Manage Mods...', 'menu.feedback': md + '  Mods & Feedback...'},
+    }
+    for sprache, t in mods.items():
+        aus['mods_' + sprache] = json.dumps(t, ensure_ascii=True, indent=2)
+    schrift = json.dumps({'providers': [{'type': 'bitmap', 'file': 'aeromc:font/symbole.png', 'ascent': 7, 'height': 8,
+                                         'chars': [''.join(SYMBOL_ZEICHEN)]}]}, ensure_ascii=True, indent=2)
+    return aus, schrift
+
+
+def knopf_dateien():
+    import json
+    knopf(False, 2).save(os.path.join(ZIEL, 'knopf.png'))
+    knopf(True, 2).save(os.path.join(ZIEL, 'knopf_hell.png'))
+    knopf(False, 4).save(os.path.join(ZIEL, 'knopf_4x.png'))
+    knopf(True, 4).save(os.path.join(ZIEL, 'knopf_hell_4x.png'))
+    meta = json.dumps({'gui': {'scaling': {'type': 'nine_slice', 'width': 200, 'height': 20, 'border': 3}}}, indent=2)
+    with open(os.path.join(ZIEL, 'knopf.png.mcmeta'), 'w', encoding='utf-8') as f:
+        f.write(meta)
+    symbole().save(os.path.join(ZIEL, 'symbole.png'))
+    puzzle(groesse=40).save(os.path.join(ZIEL, 'mods_knopf.png'))   # Symbol-Knopf im Pausemenü (26.x)
+    sprachen, schrift = sprachdateien()
+    for sprache, text in sprachen.items():
+        with open(os.path.join(ZIEL, f'lang_{sprache}.json'), 'w', encoding='utf-8') as f:
+            f.write(text)
+    with open(os.path.join(ZIEL, 'font_default.json'), 'w', encoding='utf-8') as f:
+        f.write(schrift)
+
+
+def main():
+    os.makedirs(ZIEL, exist_ok=True)
+    titel(False).save(os.path.join(ZIEL, 'titel_neu.png'))
+    titel(True).save(os.path.join(ZIEL, 'titel_alt.png'))
+    # Der Untertitel steckt jetzt im Titel-Logo – edition.png bleibt leer
+    leer = Image.new('RGBA', (512, 64), (0, 0, 0, 0))
+    leer.save(os.path.join(ZIEL, 'edition_neu.png'))
+    leer.save(os.path.join(ZIEL, 'edition_alt.png'))
+
+    equi, flach = quelle('panorama'), quelle('hintergrund')
+    if equi is not None:
+        seiten = wuerfelseiten(equi)          # echtes Rundum-Panorama
+    elif flach is not None:
+        seiten = seiten_aus_bild(flach)       # flaches Bild, nahtlos gespiegelt
+    else:
+        seiten = wuerfelseiten(landschaft())  # gezeichnete Block-Landschaft
+    for i, s in enumerate(seiten):
+        s.save(os.path.join(ZIEL, f'panorama_{i}.png'), optimize=True)
+
+    lade = ladebild()
+    lade.save(os.path.join(QUELLE if os.path.isdir(QUELLE) else ZIEL, '_vorschau_ladebildschirm.png'))
+    als_logotextur(lade).save(os.path.join(ZIEL, 'ladelogo.png'), optimize=True)
+    # derselbe Ladebildschirm ohne Text – für den Neustart über den Mod-Schalter
+    ladebild(mit_text=False).save(os.path.join(ZIEL, 'neustart.jpg'), quality=88)
+
+    # 1.14/1.15: festes 256×256-Feld in der Mitte, Logo auf durchsichtigem Grund
+    alt = Image.new('RGBA', (1024, 1024), (0, 0, 0, 0))
+    art, _ = logo(26)
+    art = einpassen(art, 980, 600)
+    alt.alpha_composite(art, ((1024 - art.width) // 2, (1024 - art.height) // 2))
+    alt.save(os.path.join(ZIEL, 'ladelogo_alt.png'))
+
+    knopf_dateien()
+
+    symbol = Image.open(LOGO).convert('RGBA')
+    symbol.resize((128, 128), Image.LANCZOS).save(os.path.join(ZIEL, 'pack.png'))
+    for n in (16, 32, 48, 64, 128, 256):
+        with open(os.path.join(ZIEL, f'icon_{n}.rgba'), 'wb') as f:
+            f.write(symbol.resize((n, n), Image.LANCZOS).tobytes())
+    print('Fertig:', ZIEL, '| Hintergrund:', 'eigenes Bild' if quelle('hintergrund') else 'Panorama-Ausschnitt',
+          '| Panorama:', 'eigenes Panorama' if quelle('panorama') else ('aus dem Hintergrundbild' if quelle('hintergrund') else 'Block-Landschaft'))
+
+
+if __name__ == '__main__':
+    main()

scripts/pruefe-version.js

@@ -0,0 +1,39 @@
+'use strict';
+
+/*
+ * pruefe-version.js – läuft vor jedem Build (prebuild)
+ * ----------------------------------------------------
+ * Bricht ab, wenn die Version aus package.json schon als Release in Gitea
+ * veröffentlicht ist. Ein neuer Build derselben Version ergäbe andere Dateien
+ * mit neuer Signatur – die bereits veröffentlichten EXEs würden dann nicht mehr
+ * dazu passen und kein Launcher nähme das Update an.
+ *
+ * Ausnahme (z. B. Testbuild, der nie hochgeladen wird): AEROMC_GLEICHE_VERSION=1
+ */
+
+const path = require('path');
+
+const API = 'https://git.viper.ipv64.net/api/v1/repos/M_Viper/AeroMc-Launcher/releases?limit=50';
+const version = require(path.join(__dirname, '..', 'package.json')).version;
+
+(async () => {
+  if (process.env.AEROMC_GLEICHE_VERSION === '1') return;
+  let releases;
+  try {
+    const res = await fetch(API, { headers: { 'User-Agent': 'AeroMC-Release', Accept: 'application/json' } });
+    if (!res.ok) throw new Error('HTTP ' + res.status);
+    releases = await res.json();
+  } catch (err) {
+    console.warn(`\n! Gitea nicht erreichbar (${err.message}) – Versionsprüfung übersprungen.`);
+    return;
+  }
+  const norm = (v) => String(v || '').trim().replace(/^v/i, '');
+  const treffer = (releases || []).find((r) => !r.draft && norm(r.tag_name) === version);
+  if (treffer) {
+    console.error(`\n✖ Version ${version} ist bereits in Gitea veröffentlicht (${treffer.published_at}).`);
+    console.error('  Bitte zuerst die Versionsnummer in package.json erhöhen – sonst passen die');
+    console.error('  veröffentlichten Dateien nicht mehr zur Signatur.');
+    process.exit(1);
+  }
+  console.log(`» Version ${version} ist noch nicht veröffentlicht – Build läuft.`);
+})();

scripts/sign-release.js

@@ -0,0 +1,227 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const readline = require('readline');
+const { execFileSync } = require('child_process');
+const { signaturText, pruefeSignatur, holeSignatur, SIGNATUR_API } = require('../src/updater');
+
+const ROOT = path.join(__dirname, '..');
+const DIST = path.join(ROOT, 'dist');
+const ORDNER = path.join(os.homedir(), '.aeromc-release');
+const OEFFENTLICH = path.join(ROOT, 'src', 'update-schluessel.pem');
+const PRIVAT = process.env.AEROMC_SIGN_KEY || path.join(ORDNER, 'release-key.pem');
+const ZUGANG = path.join(ORDNER, 'wordpress.json');
+const DATEIEN = { setup: 'AeroMC-Setup.exe', portable: 'AeroMC-Portable.exe' };
+const WP_STANDARD = new URL(SIGNATUR_API).origin;
+
+// ---------------------------------------------------------------------------
+// Schlüssel
+// ---------------------------------------------------------------------------
+
+function schluesselAnlegen() {
+  if (fs.existsSync(PRIVAT)) {
+    console.log(`Es gibt bereits einen Release-Schlüssel: ${PRIVAT}`);
+    console.log('Er wird nicht überschrieben – sonst nähmen bestehende Launcher keine Updates mehr an.');
+    return;
+  }
+  const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+  fs.mkdirSync(path.dirname(PRIVAT), { recursive: true });
+  fs.writeFileSync(PRIVAT, privateKey.export({ type: 'pkcs8', format: 'pem' }), { mode: 0o600 });
+  fs.writeFileSync(OEFFENTLICH, publicKey.export({ type: 'spki', format: 'pem' }));
+  console.log(`Privater Schlüssel: ${PRIVAT}   (SICHERN, niemals weitergeben!)`);
+  console.log(`Öffentlicher Schlüssel: ${OEFFENTLICH}   (wird in den Launcher eingebaut)`);
+}
+
+
+function dpapi(skript, eingabe) {
+  return execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', skript],
+    { input: eingabe, encoding: 'utf8', windowsHide: true }).trim();
+}
+function verschluesseln(text) {
+  return dpapi('$t = [Console]::In.ReadToEnd(); ConvertTo-SecureString $t -AsPlainText -Force | ConvertFrom-SecureString', text);
+}
+function entschluesseln(hex) {
+  return dpapi('$h = [Console]::In.ReadToEnd().Trim(); $s = ConvertTo-SecureString $h; '
+    + '[Runtime.InteropServices.Marshal]::PtrToStringBSTR([Runtime.InteropServices.Marshal]::SecureStringToBSTR($s))', hex);
+}
+
+function frage(text, verdeckt) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    if (verdeckt) {
+      rl._writeToOutput = (s) => { if (s.includes(text)) process.stdout.write(text); else if (s === '\r\n' || s === '\n') process.stdout.write(s); };
+    }
+    rl.question(text, (antwort) => { rl.close(); if (verdeckt) process.stdout.write('\n'); resolve(antwort.trim()); });
+  });
+}
+
+function ladeZugang() {
+  if (!fs.existsSync(ZUGANG)) return null;
+  const z = JSON.parse(fs.readFileSync(ZUGANG, 'utf8').replace(/^/, '')); 
+  return { seite: z.seite, benutzer: z.benutzer, passwort: entschluesseln(z.passwort) };
+}
+
+function kopfzeilen(zugang) {
+  const daten = Buffer.from(`${zugang.benutzer}:${zugang.passwort}`).toString('base64');
+  return {
+    Authorization: 'Basic ' + daten,
+    // Ersatz für Server, die "Authorization" nicht an PHP weitergeben (siehe signaturen.php)
+    'X-AeroMC-Auth': daten,
+    'Content-Type': 'application/json',
+    'User-Agent': 'AeroMC-Release',
+  };
+}
+
+// Übersetzt die Diagnose des Plugins (ab 1.5.4) in eine klare Meldung
+function zugangsFehler(d, benutzer) {
+  if (!d || !d.version) {
+    return 'Das Plugin auf der Seite ist zu alt – bitte "AeroMC Freunde" 1.5.4 oder neuer installieren.';
+  }
+  if (!d.anwendungspasswoerter) return 'Anwendungspasswörter sind auf der Seite abgeschaltet (z. B. durch ein Sicherheits-Plugin).';
+  if (!d.authorization_kommt_an && !d.eigener_kopf_kommt_an) {
+    return 'Der Server leitet keine Anmeldedaten an WordPress weiter (beide Header fehlen) – das muss der Hoster freigeben.';
+  }
+  switch (d.grund) {
+    case 'invalid_username': return `Den Benutzer "${benutzer}" gibt es nicht (Benutzername, nicht E-Mail-Adresse).`;
+    case 'incorrect_password':
+      return 'Falsches Anwendungspasswort. Achtung: Gemeint ist NICHT das Login-Passwort, sondern das unter '
+        + 'Benutzer → Profil → "Anwendungspasswörter" erzeugte (Form "abcd efgh ijkl …").';
+    case 'application_passwords_disabled':
+    case 'application_passwords_disabled_for_user':
+      return `Für "${benutzer}" sind Anwendungspasswörter abgeschaltet.`;
+    default: break;
+  }
+  if (d.benutzer && !d.darf_hochladen) {
+    return `Anmeldung als "${d.benutzer}" klappt, aber der Benutzer hat nicht die Rolle "AeroMC Release" (Benutzer bearbeiten → Rolle).`;
+  }
+  return 'Anmeldung abgelehnt' + (d.grund ? ` (${d.grund})` : '') + '.';
+}
+
+async function pruefeZugang(zugang) {
+  const res = await fetch(`${zugang.seite}/wp-json/aeromc/v1/update-signatur/zugang`, { headers: kopfzeilen(zugang) });
+  if (res.status === 404) throw new Error('Die Seite kennt die Signatur-Schnittstelle nicht – ist das Plugin "AeroMC Freunde" (ab 1.5.4) installiert und aktiviert?');
+  let d = null;
+  try { d = await res.json(); } catch { /* keine JSON-Antwort */ }
+  if (res.ok && d && d.ok) return d;
+  if (res.status === 401 || res.status === 403) throw new Error(zugangsFehler(d, zugang.benutzer));
+  throw new Error('WordPress antwortet mit HTTP ' + res.status);
+}
+
+async function wordpressEinrichten() {
+  console.log('WordPress-Zugang für das automatische Hochladen der Signaturen einrichten.');
+  console.log('Vorher in WordPress: Benutzer mit der Rolle "AeroMC Release" anlegen, dann in dessen Profil');
+  console.log('unter "Anwendungspasswörter" ein Passwort erzeugen (Name z. B. "AeroMC Build").\n');
+  const seite = (await frage(`Adresse der WordPress-Seite [${WP_STANDARD}]: `)) || WP_STANDARD;
+  if (!/^https:\/\//i.test(seite)) throw new Error('Bitte eine https://-Adresse angeben.');
+  const benutzer = await frage('WordPress-Benutzername: ');
+  const passwort = await frage('Anwendungspasswort (Eingabe bleibt unsichtbar): ', true);
+  if (!benutzer || !passwort) throw new Error('Benutzername und Passwort werden gebraucht.');
+  const zugang = { seite: seite.replace(/\/+$/, ''), benutzer, passwort };
+  const antwort = await pruefeZugang(zugang);
+  fs.mkdirSync(ORDNER, { recursive: true });
+  fs.writeFileSync(ZUGANG, JSON.stringify({ seite: zugang.seite, benutzer, passwort: verschluesseln(passwort) }, null, 2), { mode: 0o600 });
+  console.log(`\n✔ Zugang geprüft (angemeldet als ${antwort.benutzer}) und gespeichert: ${ZUGANG}`);
+  console.log('  Das Passwort ist mit Windows-DPAPI verschlüsselt.');
+}
+
+
+
+function sha256(datei) {
+  const h = crypto.createHash('sha256');
+  const fd = fs.openSync(datei, 'r');
+  const buf = Buffer.alloc(4 * 1024 * 1024);
+  let n;
+  while ((n = fs.readSync(fd, buf, 0, buf.length, null)) > 0) h.update(buf.subarray(0, n));
+  fs.closeSync(fd);
+  return h.digest('hex');
+}
+
+function signieren(art) {
+  const name = DATEIEN[art];
+  if (!name) throw new Error(`Unbekannte Art "${art}" – erwartet: setup, portable, schluessel, wordpress oder hochladen.`);
+  const datei = path.join(DIST, name);
+  if (!fs.existsSync(datei)) throw new Error(`${datei} fehlt – erst bauen.`);
+  if (!fs.existsSync(PRIVAT)) {
+    throw new Error(`Kein Release-Schlüssel unter ${PRIVAT}. Einmalig "node scripts/sign-release.js schluessel" ausführen.`);
+  }
+  const privat = crypto.createPrivateKey(fs.readFileSync(PRIVAT, 'utf8'));
+
+  const eingebaut = crypto.createPublicKey(fs.readFileSync(OEFFENTLICH, 'utf8')).export({ type: 'spki', format: 'der' });
+  const passend = crypto.createPublicKey(privat).export({ type: 'spki', format: 'der' });
+  if (!eingebaut.equals(passend)) {
+    throw new Error('Der private Schlüssel passt nicht zu src/update-schluessel.pem – Signatur wäre für den Launcher wertlos.');
+  }
+
+  const version = require(path.join(ROOT, 'package.json')).version;
+  const hash = sha256(datei);
+  const sig = {
+    format: 'AeroMC-Update/1',
+    datei: name,
+    version,
+    sha256: hash,
+    signatur: crypto.sign(null, signaturText(name, version, hash), privat).toString('base64'),
+  };
+  pruefeSignatur(sig, name, version, hash);   
+  fs.writeFileSync(datei + '.sig', JSON.stringify(sig, null, 2) + '\n');
+  console.log(`\n» ${name} ${version} signiert`);
+  return sig;
+}
+
+async function hochladen(sig) {
+  const zugang = ladeZugang();
+  if (!zugang) {
+    throw new Error('Kein WordPress-Zugang eingerichtet – Signatur NICHT hochgeladen.\n'
+      + '  Einmalig ausführen:  node scripts/sign-release.js wordpress\n'
+      + `  danach:              node scripts/sign-release.js hochladen ${sig.datei === DATEIEN.setup ? 'setup' : 'portable'}`);
+  }
+  // Nie die Signatur einer schon veröffentlichten Datei überschreiben: Dann passte
+  // die EXE im Gitea-Release nicht mehr, und kein Launcher nähme das Update an.
+  const vorhanden = await holeSignatur(sig.datei, sig.version);
+  if (vorhanden && vorhanden.sha256 !== sig.sha256 && process.env.AEROMC_SIG_ERSETZEN !== '1') {
+    throw new Error(`Für ${sig.datei} ${sig.version} liegt schon eine andere Signatur auf WordPress – `
+      + 'diese Version ist vermutlich bereits veröffentlicht. Bitte die Versionsnummer in package.json erhöhen.\n'
+      + '  (Nur wenn die Version sicher NICHT veröffentlicht ist: AEROMC_SIG_ERSETZEN=1 setzen.)');
+  }
+  if (vorhanden && vorhanden.sha256 === sig.sha256) {
+    console.log('» Signatur liegt bereits unverändert auf WordPress.');
+    return;
+  }
+  const res = await fetch(`${zugang.seite}/wp-json/aeromc/v1/update-signatur`, {
+    method: 'POST', headers: kopfzeilen(zugang), body: JSON.stringify(sig),
+  });
+  let antwort = {};
+  try { antwort = await res.json(); } catch { /* leer */ }
+  if (!res.ok || !antwort.ok) {
+    throw new Error(`Hochladen fehlgeschlagen (HTTP ${res.status}): ${antwort.message || 'unbekannter Fehler'}`);
+  }
+  // Gegenprobe: liefert die öffentliche Schnittstelle genau das, was der Launcher braucht?
+  const zurueck = await holeSignatur(sig.datei, sig.version);
+  if (!zurueck || zurueck.signatur !== sig.signatur || zurueck.sha256 !== sig.sha256) {
+    throw new Error('Signatur wurde hochgeladen, die Seite liefert aber etwas anderes zurück (Cache?).');
+  }
+  console.log(`» Signatur auf ${zugang.seite} hochgeladen und geprüft${antwort.geprueft ? ' (vom Server gegengeprüft)' : ''} – ins Gitea-Release kommt nur die EXE.`);
+}
+
+async function main() {
+  const [art, zusatz] = process.argv.slice(2);
+  if (art === 'schluessel') return schluesselAnlegen();
+  if (art === 'wordpress') return wordpressEinrichten();
+  if (art === 'hochladen') {
+    const name = DATEIEN[zusatz];
+    if (!name) throw new Error('Erwartet: hochladen setup|portable');
+    const sigDatei = path.join(DIST, name + '.sig');
+    if (!fs.existsSync(sigDatei)) throw new Error(`${sigDatei} fehlt – erst bauen und signieren.`);
+    const sig = JSON.parse(fs.readFileSync(sigDatei, 'utf8'));
+    pruefeSignatur(sig, name, sig.version, sha256(path.join(DIST, name)));   
+    return hochladen(sig);
+  }
+  return hochladen(signieren(art));
+}
+
+main().catch((err) => {
+  console.error('\n✖ ' + err.message);
+  process.exit(1);
+});

server/curseforge-proxy/index.js

@@ -1,58 +1,29 @@
 'use strict';
 
-/*
- * AeroMC – CurseForge-Weiterleitung
- * ---------------------------------
- * Hält den CurseForge-API-Schlüssel und stellt die Anfragen stellvertretend
- * für den Launcher. So bleibt der Schlüssel auf dem Server: in der verteilten
- * .exe wäre er für jeden auslesbar, und CurseForge untersagt die Weitergabe
- * an Dritte ausdrücklich.
- *
- * Wege:
- *   GET  /health                  – Lebenszeichen, ohne Schlüsselangaben
- *   POST /v1/mods/files           – Dateiliste auflösen (Rumpf: { fileIds: [...] })
- *   GET  /v1/download?url=...     – Mod-Datei durchreichen (CDN verlangt seit
- *                                   Juli 2026 ebenfalls einen Schlüssel)
- *
- * Einstellungen über Umgebungsvariablen, siehe .env.example.
- */
-
 const http = require('http');
 const { Readable } = require('stream');
 
 const KEY = (process.env.CF_API_KEY || '').trim();
 const PORT = Number(process.env.PORT || 8420);
 const HOST = process.env.HOST || '0.0.0.0';
-/*
+
- * Ein oder mehrere gültige Token, durch Komma getrennt.
- *
- * Mehrere deshalb, weil das Token in ausgelieferten Paketen steckt: Beim
- * Wechsel trägst du eine Zeit lang altes und neues ein, damit ältere
- * Installationen weiterlaufen, bis alle das Update haben. Danach das alte
- * streichen.
- */
 const TOKENS = new Set(
   String(process.env.CF_PROXY_TOKEN || '')
     .split(',').map((t) => t.trim()).filter(Boolean),
 );
 const LIMIT_PRO_MIN = Number(process.env.RATE_LIMIT_PER_MIN || 60);
 const MAX_MB = Number(process.env.MAX_DOWNLOAD_MB || 512);
-// Anzahl der Reverse-Proxies davor. 0 = keiner, 1 = z. B. Nginx Proxy Manager,
+
-// 2 = z. B. Cloudflare vor dem Proxy Manager.
 const PROXY_STUFEN = Math.max(0, Number(process.env.TRUST_PROXY || 0) || 0);
 
 const CF_API = 'https://api.curseforge.com/v1';
 
-// Ohne User-Agent weisen Dienste hinter Cloudflare Anfragen gerne mit 403 ab.
 const UA = 'AeroMC-Launcher-Proxy/1.0 (+https://git.viper.ipv64.net)';
 
 function cfKopfzeilen(weitere) {
   return Object.assign({ 'x-api-key': KEY, Accept: 'application/json', 'User-Agent': UA }, weitere || {});
 }
 
-// Nur diese Hosts dürfen durchgereicht werden. Ohne diese Liste wäre der
-// Server ein offenes Tor in dein Netz – jemand könnte ihn Adressen im
-// Heimnetz abrufen lassen und die Antwort mitlesen.
 const ERLAUBTE_HOSTS = new Set([
   'edge.forgecdn.net',
   'mediafilez.forgecdn.net',

src/assets/spieldesign/font_default.json

@@ -0,0 +1,13 @@
+{
+  "providers": [
+    {
+      "type": "bitmap",
+      "file": "aeromc:font/symbole.png",
+      "ascent": 7,
+      "height": 8,
+      "chars": [
+        "\ue900\ue901\ue902\ue903\ue904\ue905"
+      ]
+    }
+  ]
+}

src/assets/spieldesign/knopf.png.mcmeta

@@ -0,0 +1,10 @@
+{
+  "gui": {
+    "scaling": {
+      "type": "nine_slice",
+      "width": 200,
+      "height": 20,
+      "border": 3
+    }
+  }
+}

src/assets/spieldesign/lang_de_de.json

@@ -0,0 +1,7 @@
+{
+  "menu.singleplayer": "\ue900  Einzelspieler",
+  "menu.multiplayer": "\ue901  Mehrspieler",
+  "menu.online": "\ue902  Minecraft Realms",
+  "menu.options": "\ue903  Optionen \u2026",
+  "menu.quit": "\ue904  Spiel beenden"
+}

src/assets/spieldesign/lang_en_us.json

@@ -0,0 +1,7 @@
+{
+  "menu.singleplayer": "\ue900  Singleplayer",
+  "menu.multiplayer": "\ue901  Multiplayer",
+  "menu.online": "\ue902  Minecraft Realms",
+  "menu.options": "\ue903  Options...",
+  "menu.quit": "\ue904  Quit Game"
+}

src/assets/spieldesign/lang_mods_de_de.json

@@ -0,0 +1,4 @@
+{
+  "menu.sendFeedback": "\ue905  Mods verwalten \u2026",
+  "menu.feedback": "\ue905  Mods & Feedback \u2026"
+}

src/assets/spieldesign/lang_mods_en_us.json

@@ -0,0 +1,4 @@
+{
+  "menu.sendFeedback": "\ue905  Manage Mods...",
+  "menu.feedback": "\ue905  Mods & Feedback..."
+}

src/assets/spieldesign/splashes.txt

@@ -0,0 +1,33 @@
+Mehr als nur Minecraft!
+Mehr als nur Minecraft!
+Mehr als nur Minecraft!
+Mehr als nur Minecraft!
+Gemeinsam mehr bauen!
+Dein Minecraft-Erlebnis!
+Gestartet mit AeroMC!
+Jetzt mit eigenen Umhängen!
+Freunde inklusive!
+Blockig, aber schön!
+Auch in Nachtlila!
+Turbo dank Leistungs-Paket!
+17 Erfolge warten!
+Mit Garderobe!
+Ein Klick, und los!
+Mods? Ein Klick!
+Diamanten nicht inklusive!
+Achtung, Creeper!
+Handgepixelt!
+Heute schon gebaut?
+Deine Welt, dein Stil!
+Spielzeit läuft mit!
+Läuft wie geschmiert!
+Kein Lag, nur Spaß!
+Lade Freunde ein!
+Schon ein Backup gemacht?
+Hallo Nachbar!
+Nur noch ein Block!
+Bitte nicht die Lava trinken!
+Jetzt auch auf Deutsch!
+Mit 100 % mehr Blau!
+Schlaf gut, Steve!
+Endlich Wochenende!

src/assets/verbot.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <circle cx="50" cy="50" r="49.5" fill="#fff" stroke="#222" stroke-width="0.6"/>
+  <circle cx="50" cy="50" r="43.8" fill="#fff" stroke="#c80000" stroke-width="11.2"/>
+  <line x1="23.4" y1="23.4" x2="76.6" y2="76.6" stroke="#c80000" stroke-width="11.2"/>
+</svg>

src/aufbau.html

@@ -0,0 +1,51 @@
+<!doctype html>
+<html lang="de">
+<head>
+  <meta charset="utf-8" />
+  <meta http-equiv="Content-Security-Policy"
+        content="default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'" />
+  <title>AeroMC</title>
+  <style>
+    html, body { margin: 0; height: 100%; overflow: hidden; background: transparent; }
+    #bild {
+      position: absolute; display: none; transform-origin: 0 0; will-change: transform, opacity;
+      border-radius: 6px; box-shadow: 0 18px 48px rgba(0, 0, 0, .45);
+    }
+  </style>
+</head>
+<body>
+  <img id="bild" alt="" />
+  <script>
+    // Hilfsfenster für "Fenster wachsen aus dem Knopf" (siehe fensteraufbau.js) – wird nach einmaligem Gebrauch geschlossen
+    const bild = document.getElementById('bild');
+    let start = 1;
+
+    // Bild an die Zielstelle legen und auf Knopfgröße zusammenschrumpfen (noch unsichtbar)
+    window.vorbereiten = (adresse, nach, von) => new Promise((fertig) => {
+      bild.onerror = () => fertig(false);
+      bild.onload = () => {
+        Object.assign(bild.style, { left: nach.x + 'px', top: nach.y + 'px', width: nach.width + 'px', height: nach.height + 'px' });
+        // wächst aus der Mitte des angeklickten Knopfs heraus (darf außerhalb liegen)
+        bild.style.transformOrigin = `${von.x + von.width / 2 - nach.x}px ${von.y + von.height / 2 - nach.y}px`;
+        start = Math.max(0.06, Math.min(0.5, Math.max(von.width / nach.width, von.height / nach.height)));
+        bild.style.transform = `scale(${start})`;
+        bild.style.opacity = '0';
+        bild.style.display = 'block';
+        // zwei Bildtakte abwarten, damit der Anfangszustand gezeichnet ist (höchstens 120 ms)
+        let erledigt = false;
+        const fertigEinmal = () => { if (!erledigt) { erledigt = true; fertig(true); } };
+        requestAnimationFrame(() => requestAnimationFrame(fertigEinmal));
+        setTimeout(fertigEinmal, 120);
+      };
+      bild.src = adresse;
+    });
+
+    window.abspielen = (ms) => bild.animate([
+      { transform: `scale(${start})`, opacity: 0 },
+      { opacity: 1, offset: 0.3 },
+      { transform: 'scale(1)', opacity: 1 },
+    ], { duration: ms, easing: 'cubic-bezier(.2, .8, .2, 1)', fill: 'forwards' }).finished.then(() => true, () => false);
+
+  </script>
+</body>
+</html>

src/cfimport.js

@@ -154,14 +154,27 @@ function scan(inputPath) {
   return { ok: true, instancesDir, count: list.length, instances: list };
 }
 
+function kopierNamen(sourceDir) {
+  return fs.readdirSync(sourceDir).filter((name) => !META_FILES.includes(name));
+}
+
 function copyInto(sourceDir, targetDir) {
   fs.mkdirSync(targetDir, { recursive: true });
-  for (const name of fs.readdirSync(sourceDir)) {
+  for (const name of kopierNamen(sourceDir)) {
-    if (META_FILES.includes(name)) continue;
     fs.cpSync(path.join(sourceDir, name), path.join(targetDir, name), { recursive: true });
   }
 }
 
+/*
+ * Was beim Übernehmen kopiert wird: [{ von, name }] – `name` ist der Zielname
+ * im Spielordner der neuen Instanz. Das Kopieren selbst erledigt kopieren.js
+ * asynchron mit Fortschritt (main.js → fuehreImportAus).
+ */
+function kopierQuellen(entry) {
+  if (!entry.gameDir || !fs.existsSync(entry.gameDir)) return [];
+  return kopierNamen(entry.gameDir).map((name) => ({ von: path.join(entry.gameDir, name), name }));
+}
+
 function importOne(store, entry, copyData = true) {
   const created = store.createOrReplaceImportedInstance({
     name: entry.name,
@@ -193,4 +206,4 @@ function importOne(store, entry, copyData = true) {
   return { id: created.id, name: created.name, copied };
 }
 
-module.exports = { scan, importOne, resolveInstancesDir };
+module.exports = { scan, importOne, kopierQuellen, resolveInstancesDir };

src/crashhelp.js

@@ -155,6 +155,15 @@ function analysiere(text, ctx = {}) {
       { typ: 'java-auto' });
   }
 
+  // --- Alte Forge-Version verträgt aktuelles Java 8 nicht ---
+  // Forge 1.16.5 vor 36.2.26 (und ähnlich alte Fassungen) nutzt eine interne
+  // Java-Klasse, die es seit Java 8u321 so nicht mehr gibt.
+  if (/sun\.security\.util\.ManifestEntryVerifier\.<init>/i.test(t) && /forge/i.test(String(ctx.loader || ''))) {
+    fund('forge-alt', 'Diese Forge-Version ist zu alt für das aktuelle Java',
+      'Ältere Forge-Versionen laufen mit aktuellem Java 8 nicht mehr (Fehler „ManifestEntryVerifier“). Eine neuere Forge-Version für dieselbe Minecraft-Version behebt das – Mods und Welten bleiben erhalten.',
+      { typ: 'forge-aktualisieren' });
+  }
+
   // --- Zu wenig Arbeitsspeicher ---
   if (/java\.lang\.OutOfMemoryError|There is insufficient memory for the Java Runtime/i.test(t)) {
     const jetzt = Number(ctx.maxMemMb) || 2048;

src/designs.css

@@ -9,8 +9,8 @@
 
 /* ===================== Design-Auswahl in den Optionen ===================== */
 .design-raster{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}
-.settings-card-wide .design-raster{grid-template-columns:repeat(5,minmax(0,1fr))}
+.settings-card .design-raster{grid-template-columns:repeat(5,minmax(0,1fr))}
-@media (max-width:900px){.settings-card-wide .design-raster{grid-template-columns:repeat(2,minmax(0,1fr))}}
+@media (max-width:900px){.settings-card .design-raster{grid-template-columns:repeat(2,minmax(0,1fr))}}
 .design-wahl{display:flex;flex-direction:column;gap:5px;padding:6px;border:1px solid var(--border);border-radius:8px;background:none;color:var(--text);font-family:inherit;font-size:12px;cursor:pointer;text-align:left}
 .design-wahl:hover{border-color:var(--sel-br)}
 .design-wahl.on{border-color:var(--sel-br);box-shadow:0 0 0 1px var(--sel-br);background:var(--sel)}
@@ -73,7 +73,7 @@
 :root:is([data-design="aero"],[data-design="lila"]) .tbtn:active{background:var(--surface2)}
 :root:is([data-design="aero"],[data-design="lila"]) .tbtn svg,
 :root:is([data-design="aero"],[data-design="lila"]) #btn-new svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-import svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-open-dir svg,
-:root:is([data-design="aero"],[data-design="lila"]) #btn-console svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-account svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-settings svg,
+:root:is([data-design="aero"],[data-design="lila"]) #btn-search svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-console svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-account svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-settings svg,
 :root:is([data-design="aero"],[data-design="lila"]) .acct-av svg{color:var(--cyan-soft)}
 :root:is([data-design="aero"],[data-design="lila"]) .tbsep{background:var(--border)}
 :root:is([data-design="aero"],[data-design="lila"]) .search-wrap input{border-radius:999px;padding:5px 12px;width:150px}
@@ -94,6 +94,10 @@
 :root:is([data-design="aero"],[data-design="lila"]) .card.sel{background:linear-gradient(180deg,rgba(var(--p-akzent),.24),rgba(var(--p-tief),.14));border-color:rgba(var(--p-akzent2),.55);box-shadow:0 10px 28px -14px rgba(var(--p-akzent),.95),0 0 0 1px rgba(var(--p-hell),.08) inset}
 :root:is([data-design="aero"],[data-design="lila"]) .card.sel .card-name{background:linear-gradient(120deg,rgb(var(--p-akzent2)),rgb(var(--p-akzent)) 60%,rgb(var(--p-tief)));color:#fff;border-radius:999px}
 :root:is([data-design="aero"],[data-design="lila"]) .card-icon-img{border-radius:10px}
+:root:is([data-design="aero"],[data-design="lila"]) .card.laeuft::after{border-color:rgb(var(--p-akzent2));--accent:rgb(var(--p-akzent2))}
+:root.ui-animiert:is([data-design="aero"],[data-design="lila"]) .lichtpunkte{display:block}
+:root:is([data-design="aero"],[data-design="lila"]) .lichtpunkte i{background:rgb(var(--p-hell));box-shadow:0 0 calc(var(--g) * 3) 1px rgba(var(--p-akzent2),.85)}
+:root:is([data-design="aero"],[data-design="lila"]) .erfolg .funke{box-shadow:0 0 5px 2px rgb(var(--p-hell)),0 0 14px 4px rgba(var(--p-akzent2),.8)}
 :root:is([data-design="aero"],[data-design="lila"]) .card-taste{border-radius:999px;background:linear-gradient(120deg,rgb(var(--p-akzent2)),rgb(var(--p-akzent)))}
 :root:is([data-design="aero"],[data-design="lila"]) .empty h2{background:linear-gradient(120deg,rgb(var(--p-hell)),rgb(var(--p-akzent)) 60%,rgb(var(--p-tief)));-webkit-background-clip:text;background-clip:text;color:transparent;font-size:26px}
 
@@ -132,7 +136,7 @@
 :root:is([data-design="aero"],[data-design="lila"]) .mods-filters select,
 :root:is([data-design="aero"],[data-design="lila"]) .mmc-bar select,
 :root:is([data-design="aero"],[data-design="lila"]) .clip-length select,
-:root:is([data-design="aero"],[data-design="lila"]) .path-row input,
+:root:is([data-design="aero"],[data-design="lila"]) .path-row input,:root:is([data-design="aero"],[data-design="lila"]) .path-row select,:root:is([data-design="aero"],[data-design="lila"]) select.s-wert,:root:is([data-design="aero"],[data-design="lila"]) input.s-wert,:root:is([data-design="aero"],[data-design="lila"]) .s-paar input,:root:is([data-design="aero"],[data-design="lila"]) .s-einheit input,
 :root:is([data-design="aero"],[data-design="lila"]) .se-farbzeile input[type=text],
 :root:is([data-design="aero"],[data-design="lila"]) .se-feld select{background:var(--input);color:var(--text);border-color:var(--border);border-radius:10px}
 :root:is([data-design="aero"],[data-design="lila"]) .search-wrap input{border-radius:999px}
@@ -145,6 +149,11 @@
 :root:is([data-design="aero"],[data-design="lila"]) input[type=checkbox],:root:is([data-design="aero"],[data-design="lila"]) input[type=radio],:root:is([data-design="aero"],[data-design="lila"]) input[type=range]{accent-color:rgb(var(--p-akzent))}
 :root:is([data-design="aero"],[data-design="lila"]) .login-usercode{background:var(--input);color:var(--text);border-color:var(--border);border-radius:12px}
 :root:is([data-design="aero"],[data-design="lila"]) .upd-notes{background:var(--input);border-radius:10px}
+:root:is([data-design="aero"],[data-design="lila"]) .upd-notes h5{color:rgb(var(--p-hell))}
+:root:is([data-design="aero"],[data-design="lila"]) .ms-spalte{background:var(--surface);border-radius:14px}
+:root:is([data-design="aero"],[data-design="lila"]) .ms-kopf input{background:var(--input);border-radius:10px}
+:root:is([data-design="aero"],[data-design="lila"]) .upd-notes li::marker{color:rgb(var(--p-akzent2))}
+:root:is([data-design="aero"],[data-design="lila"]) .upd-notes a{color:rgb(var(--p-hell))}
 
 /* Knöpfe – rund wie auf der Webseite */
 :root:is([data-design="aero"],[data-design="lila"]) .btn{border-radius:999px;padding:7px 15px;background:var(--surface);border-color:var(--border);color:var(--text);transition:background .15s,border-color .15s,transform .15s}
@@ -190,6 +199,7 @@
 :root:is([data-design="aero"],[data-design="lila"]) .snav:hover{background:var(--surface)}
 :root:is([data-design="aero"],[data-design="lila"]) .snav.on{background:linear-gradient(120deg,rgba(var(--p-akzent),.30),rgba(var(--p-tief),.18));border-color:rgba(var(--p-akzent2),.40);box-shadow:none}
 :root:is([data-design="aero"],[data-design="lila"]) .settings-card{background:var(--surface);border-color:var(--border);border-radius:16px}
+:root:is([data-design="aero"],[data-design="lila"]) .schalter input:checked+i{background:linear-gradient(120deg,rgb(var(--p-akzent)),rgb(var(--p-akzent2)));box-shadow:0 0 10px -2px rgba(var(--p-akzent),.8)}
 :root:is([data-design="aero"],[data-design="lila"]) .settings-kv-row,
 :root:is([data-design="aero"],[data-design="lila"]) .about-brand{border-bottom-color:var(--border2)}
 :root:is([data-design="aero"],[data-design="lila"]) .appinfo-item{background:rgba(var(--p-linie),.04);border-color:var(--border2);border-radius:12px}
@@ -197,6 +207,12 @@
 :root:is([data-design="aero"],[data-design="lila"]) .settings-hero h4{background:linear-gradient(120deg,rgb(var(--p-hell)),rgb(var(--p-akzent)) 70%);-webkit-background-clip:text;background-clip:text;color:transparent}
 
 /* Kontextmenü, Hinweis, Bildlaufleisten */
+/* Erfolg-Meldung: Glas-Karte mit Leuchtrand wie die Webseite */
+:root:is([data-design="aero"],[data-design="lila"]) .erfolg{background:linear-gradient(135deg,rgba(var(--p-akzent),.22),var(--surface) 55%);border:1px solid rgba(var(--p-akzent),.45);border-radius:14px;
+  box-shadow:0 0 0 1px rgba(255,255,255,.04) inset,0 18px 40px -12px rgba(0,0,0,.8),0 0 24px -8px rgba(var(--p-akzent),.7)}
+:root:is([data-design="aero"],[data-design="lila"]) .erfolg-symbol{border-radius:10px;background:rgba(var(--p-akzent),.18)}
+:root:is([data-design="aero"],[data-design="lila"]) .erfolg-kopf{color:rgb(var(--p-hell))}
+:root:is([data-design="aero"],[data-design="lila"]) .erfolg-karte{border-radius:12px;background:var(--surface)}
 :root:is([data-design="aero"],[data-design="lila"]) .ctx{background:var(--surface);border-color:var(--border);border-radius:12px;box-shadow:0 18px 40px -12px rgba(0,0,0,.8)}
 :root:is([data-design="aero"],[data-design="lila"]) .ctx-item{border-radius:8px}
 :root:is([data-design="aero"],[data-design="lila"]) .ctx-item:hover{background:rgba(var(--p-akzent),.22)}
@@ -267,10 +283,14 @@
 :root[data-design="minecraft"] .toolbar{
   background:url(assets/design/gras.png) 0 0/32px 8px repeat-x,url(assets/design/schiefer.png) 0 0/64px 64px;
   image-rendering:pixelated;border-bottom:2px solid #000;padding:11px 8px 6px}
+:root[data-design="minecraft"] .toolbar{position:relative;isolation:isolate}
+:root.ui-animiert[data-design="minecraft"] .toolbar::before{content:'';position:absolute;inset:0;z-index:-1;pointer-events:none;opacity:.18;
+  background:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='512' height='48' shape-rendering='crispEdges' fill='white'><rect x='20' y='8' width='56' height='8'/><rect x='8' y='16' width='96' height='8'/><rect x='170' y='22' width='40' height='6'/><rect x='158' y='28' width='80' height='8'/><rect x='184' y='36' width='36' height='4'/><rect x='300' y='4' width='72' height='8'/><rect x='288' y='12' width='120' height='8'/><rect x='312' y='20' width='64' height='6'/><rect x='438' y='26' width='48' height='8'/><rect x='426' y='34' width='70' height='6'/></svg>") 0 0/512px 100% repeat-x;animation:wolken-ziehen 70s steps(512) infinite}
+@keyframes wolken-ziehen{to{background-position:512px 0}}
 :root[data-design="minecraft"] .tbtn{color:#fff;border-radius:0;text-shadow:1px 1px 0 #1a1a1a;image-rendering:auto}
 :root[data-design="minecraft"] .tbtn:hover{background:rgba(0,0,0,.35);border-color:#fff}
 :root[data-design="minecraft"] .tbtn:active{background:rgba(0,0,0,.5)}
-:root[data-design="minecraft"] .tbtn svg,:root[data-design="minecraft"] #btn-console svg,:root[data-design="minecraft"] .acct-av svg{color:#e6e6e6}
+:root[data-design="minecraft"] #btn-search svg,:root[data-design="minecraft"] .tbtn svg,:root[data-design="minecraft"] #btn-console svg,:root[data-design="minecraft"] .acct-av svg{color:#e6e6e6}
 :root[data-design="minecraft"] #btn-new svg,:root[data-design="minecraft"] #btn-account svg{color:#7fd858}
 :root[data-design="minecraft"] #btn-import svg{color:#6db8ff}
 :root[data-design="minecraft"] #btn-open-dir svg{color:#f2c94c}
@@ -288,7 +308,7 @@
 :root[data-design="minecraft"] .mods-filters select,
 :root[data-design="minecraft"] .mmc-bar select,
 :root[data-design="minecraft"] .clip-length select,
-:root[data-design="minecraft"] .path-row input,
+:root[data-design="minecraft"] .path-row input,:root[data-design="minecraft"] .path-row select,:root[data-design="minecraft"] select.s-wert,:root[data-design="minecraft"] input.s-wert,:root[data-design="minecraft"] .s-paar input,:root[data-design="minecraft"] .s-einheit input,
 :root[data-design="minecraft"] .login-usercode,
 :root[data-design="minecraft"] .upd-notes,
 :root[data-design="minecraft"] .se-farbzeile input[type=text],
@@ -308,6 +328,8 @@
 :root[data-design="minecraft"] .list{image-rendering:auto}
 :root[data-design="minecraft"] .group-header{font-family:var(--pixel);font-size:16px;font-weight:400;color:#fff;text-shadow:var(--mc-schatten);padding:8px 4px 4px}
 :root[data-design="minecraft"] .group-count{color:#b8b9bc}
+:root[data-design="minecraft"] .group-sub > .group-header{font-size:14px}
+:root[data-design="minecraft"] .group-sub{border-left:2px solid rgba(0,0,0,.45)}
 :root[data-design="minecraft"] .group-header .chev{color:#fff;font-family:"Segoe UI",sans-serif;font-size:10px}
 :root[data-design="minecraft"] .group-header::after{height:2px;background:rgba(0,0,0,.55);box-shadow:0 1px 0 rgba(255,255,255,.08)}
 :root[data-design="minecraft"] .card{border-radius:0}
@@ -317,6 +339,11 @@
 :root[data-design="minecraft"] .card.sel .card-name{background:none;color:#ffff7f;border-radius:0}
 :root[data-design="minecraft"] .card-taste{border-radius:0;background:#3c8527;box-shadow:inset -1px -1px 0 #1d4d13}
 :root[data-design="minecraft"] .card-icon-img{border-radius:0}
+:root[data-design="minecraft"] .card.laeuft::after{border-color:#7fd858;--accent:#7fd858;border-radius:0}
+/* Abbau-Risse: Download-Fortschritt auf dem Block, beim Fertigwerden springt er kurz */
+:root[data-design="minecraft"] .card.abbau .card-riss{display:block}
+:root.ui-animiert[data-design="minecraft"] .card.abgebaut .card-icon,:root.ui-animiert[data-design="minecraft"] .card.abgebaut .card-icon-img{animation:block-bricht .45s cubic-bezier(.3,.7,.4,1)}
+@keyframes block-bricht{0%{transform:scale(.8)}45%{transform:scale(1.14)}100%{transform:none}}
 :root[data-design="minecraft"] .empty h2{font-family:var(--pixel);font-weight:400;font-size:24px;color:#fff;text-shadow:3px 3px 0 #3f3f3f}
 :root[data-design="minecraft"] .empty p{color:#d0d0d0}
 
@@ -330,6 +357,8 @@
 :root[data-design="minecraft"] .hr{background:#000;height:2px;margin:6px 0}
 :root[data-design="minecraft"] .sbtn{margin-bottom:3px;padding:5px 2px}
 :root[data-design="minecraft"] .sbtn.play{font-family:var(--pixel);font-size:16px;font-weight:400;padding:6px 4px 7px;text-shadow:var(--mc-schatten)}
+:root[data-design="minecraft"] .sbtn.play::before,:root:is([data-design="aero"],[data-design="lila"]) .sbtn.play::before{background:#fff;opacity:.28}
+:root[data-design="minecraft"] .sbtn.play.laedt .play-text{font-size:13px}
 
 /* Statusleiste */
 :root[data-design="minecraft"] .statusbar{background:url(assets/design/schiefer.png) 0 0/64px 64px;image-rendering:pixelated;border-top:2px solid #000}
@@ -389,6 +418,10 @@
 :root[data-design="minecraft"] .settings-hero h4{font-family:var(--pixel);font-size:24px;font-weight:400;text-shadow:3px 3px 0 #3f3f3f}
 :root[data-design="minecraft"] .settings-hero p{color:#d0d0d0}
 :root[data-design="minecraft"] .settings-card{background:#313233;border:2px solid #000;border-radius:0;box-shadow:inset 2px 2px 0 #5a5b5d,inset -2px -2px 0 #1e1e1f}
+:root[data-design="minecraft"] .schalter i{border-radius:0;background:#1e1e1f;box-shadow:inset 2px 2px 0 #000}
+:root[data-design="minecraft"] .schalter i::after{border-radius:0;background:#c6c6c6;box-shadow:inset -2px -2px 0 #555,inset 2px 2px 0 #fff}
+:root[data-design="minecraft"] .schalter input:checked+i{background:#3c8527}
+:root[data-design="minecraft"] .s-zeile{border-top-color:rgba(0,0,0,.55)}
 :root[data-design="minecraft"] .settings-card h5{font-family:var(--pixel);font-size:16px;font-weight:400;text-shadow:var(--mc-schatten)}
 :root[data-design="minecraft"] .settings-kv-row,
 :root[data-design="minecraft"] .about-brand{border-bottom-color:#1a1a1b}
@@ -397,6 +430,12 @@
 :root[data-design="minecraft"] .spane h4{font-family:var(--pixel);font-size:16px;font-weight:400;text-shadow:var(--mc-schatten)}
 
 /* Kontextmenü, Hinweis, Bildlaufleisten */
+/* Erfolg-Meldung wie im Spiel („Erfolg erzielt!“) */
+:root[data-design="minecraft"] .erfolg{background:#212121;border:2px solid #555;border-radius:0;box-shadow:inset 2px 2px 0 #373737,inset -2px -2px 0 #141414,0 10px 24px rgba(0,0,0,.45);color:#fff;font-family:"AeroPixel","Segoe UI",sans-serif}
+:root[data-design="minecraft"] .erfolg-symbol{border-radius:0;background:#8b8b8b;box-shadow:inset 2px 2px 0 #373737,inset -2px -2px 0 #fff}
+:root[data-design="minecraft"] .erfolg-kopf{color:#ffff55;font-size:14px;font-weight:400;letter-spacing:0;text-transform:none}
+:root[data-design="minecraft"] .erfolg-name{font-size:14px;font-weight:400}
+:root[data-design="minecraft"] .erfolg-karte{border-radius:0;border:2px solid #000;background:rgba(0,0,0,.35)}
 :root[data-design="minecraft"] .ctx{background:#1e1e1f;border:2px solid #000;border-radius:0;box-shadow:inset 1px 1px 0 #48494a,0 8px 24px rgba(0,0,0,.5)}
 :root[data-design="minecraft"] .ctx-item{border-radius:0;text-shadow:1px 1px 0 #000}
 :root[data-design="minecraft"] .ctx-item:hover{background:#3c8527}

src/erfolge.js

@@ -0,0 +1,73 @@
+/*
+ * Erfolge im Minecraft-Stil („Erfolg erzielt!“).
+ *
+ * Bewertet wird aus dem, was der Launcher ohnehin weiß (Instanzen, Spielzeit,
+ * Starts, Mods), plus ein paar Merkern für einzelne Aktionen (Umhang
+ * hochgeladen, Skin im Editor übernommen, Leistungs-Paket …). Freigeschaltete
+ * Erfolge landen mit Datum in userData/erfolge.json.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const STUNDE = 3600;
+const LISTE = [
+  { id: 'erster-start', symbol: 'grass', titel: 'Los geht’s!', text: 'Starte zum ersten Mal ein Spiel mit AeroMC.', pruefe: (w) => w.starts >= 1 },
+  { id: 'starts-10', symbol: 'pickaxe', titel: 'Stammgast', text: 'Starte 10-mal ein Spiel.', pruefe: (w) => w.starts >= 10 },
+  { id: 'starts-100', symbol: 'gold', titel: 'Ohne mich geht nichts', text: 'Starte 100-mal ein Spiel.', pruefe: (w) => w.starts >= 100 },
+  { id: 'zeit-1', symbol: 'map', titel: 'Erste Stunde', text: 'Spiele insgesamt eine Stunde.', pruefe: (w) => w.sekunden >= STUNDE },
+  { id: 'zeit-10', symbol: 'sword', titel: 'Zeit vergeht wie im Flug', text: 'Spiele insgesamt 10 Stunden.', pruefe: (w) => w.sekunden >= 10 * STUNDE },
+  { id: 'zeit-50', symbol: 'diamond', titel: 'Abenteurer', text: 'Spiele insgesamt 50 Stunden.', pruefe: (w) => w.sekunden >= 50 * STUNDE },
+  { id: 'zeit-100', symbol: 'star', titel: 'Lebt in Minecraft', text: 'Spiele insgesamt 100 Stunden.', pruefe: (w) => w.sekunden >= 100 * STUNDE },
+  { id: 'instanzen-5', symbol: 'chest', titel: 'Sammler', text: 'Lege 5 Instanzen an.', pruefe: (w) => w.instanzen >= 5 },
+  { id: 'instanzen-10', symbol: 'book', titel: 'Archivar', text: 'Lege 10 Instanzen an.', pruefe: (w) => w.instanzen >= 10 },
+  { id: 'versionen-3', symbol: 'end', titel: 'Zeitreisender', text: 'Spiele 3 verschiedene Minecraft-Versionen.', pruefe: (w) => w.versionen >= 3 },
+  { id: 'erste-mod', symbol: 'redstone', titel: 'Bastler', text: 'Habe die erste Mod in einer Instanz.', pruefe: (w) => w.mods >= 1 },
+  { id: 'mods-50', symbol: 'potion', titel: 'Mod-Meister', text: 'Habe 50 Mods in deinen Instanzen.', pruefe: (w) => w.mods >= 50 },
+  { id: 'modpack', symbol: 'nether', titel: 'Das volle Paket', text: 'Installiere ein Modpack.', pruefe: (w) => w.modpacks >= 1 },
+  { id: 'freund', symbol: 'creeper', titel: 'Gemeinsam statt einsam', text: 'Füge deinen ersten Freund hinzu.', pruefe: (w) => w.freunde >= 1 },
+  { id: 'umhang', symbol: 'star', titel: 'Modeschöpfer', text: 'Lade einen eigenen AeroMC-Umhang hoch.', pruefe: (w) => w.merker.umhang },
+  { id: 'skin-editor', symbol: 'map', titel: 'Pixelkünstler', text: 'Übernimm einen im Skin-Editor gemalten Skin.', pruefe: (w) => w.merker['skin-editor'] },
+  { id: 'leistung', symbol: 'tnt', titel: 'Turbo', text: 'Installiere das Leistungs-Paket.', pruefe: (w) => w.merker.leistung },
+];
+
+let datei = null;
+function init(userDataDir) { datei = path.join(userDataDir, 'erfolge.json'); }
+
+function lies() {
+  try { return JSON.parse(fs.readFileSync(datei, 'utf8')); } catch { return null; }
+}
+function schreibe(stand) {
+  try { fs.writeFileSync(datei, JSON.stringify(stand, null, 1)); } catch { /* nicht schlimm */ }
+}
+
+/**
+ * werte: { starts, sekunden, instanzen, versionen, mods, modpacks, freunde }
+ * merker: zusätzliche Einzel-Aktionen ({ umhang: true } …)
+ * -> { neu: [Erfolge], ersteAuswertung }
+ */
+function pruefe(werte, merker = {}) {
+  const vorher = lies();
+  const stand = vorher || { freigeschaltet: {}, merker: {} };
+  Object.assign(stand.merker, merker);
+  const w = Object.assign({ starts: 0, sekunden: 0, instanzen: 0, versionen: 0, mods: 0, modpacks: 0, freunde: 0 }, werte, { merker: stand.merker });
+  const neu = [];
+  const jetzt = new Date().toISOString();
+  for (const e of LISTE) {
+    if (stand.freigeschaltet[e.id]) continue;
+    let erreicht = false;
+    try { erreicht = !!e.pruefe(w); } catch { /* Wert fehlt */ }
+    if (erreicht) { stand.freigeschaltet[e.id] = jetzt; neu.push(oeffentlich(e, jetzt)); }
+  }
+  if (neu.length || !vorher || Object.keys(merker).length) schreibe(stand);
+  return { neu, ersteAuswertung: !vorher };
+}
+
+const oeffentlich = (e, am) => ({ id: e.id, symbol: e.symbol, titel: e.titel, text: e.text, am: am || null });
+
+/** Alle Erfolge mit Datum (null = noch offen). */
+function liste() {
+  const stand = lies() || { freigeschaltet: {} };
+  return LISTE.map((e) => oeffentlich(e, stand.freigeschaltet[e.id] || null));
+}
+
+module.exports = { init, pruefe, liste };

src/fensteraufbau.js

@@ -0,0 +1,85 @@
+/*
+ * "Fenster wachsen aus dem Knopf": Ein Popup-Fenster (Optionen, Mods, Skin,
+ * Freunde …) erscheint nicht schlagartig, sondern wächst aus dem angeklickten
+ * Knopf heraus. Dafür wird das noch unsichtbare Fenster abfotografiert und das
+ * Bild in einem durchsichtigen Hilfsfenster vom Knopf aus groß gezogen; am Ende
+ * übernimmt das echte Fenster an exakt derselben Stelle.
+ *
+ * Das Hilfsfenster entsteht jedes Mal neu und gleich in der richtigen Größe:
+ * Unter Windows färbt sich ein durchsichtiges Fenster schwarz, sobald es
+ * nachträglich vergrößert wird, und ein verstecktes Fenster zeichnet nicht mehr.
+ * Abschaltbar unter Optionen → Darstellung → Animationen („Bewegte Oberfläche“).
+ */
+const path = require('path');
+const { BrowserWindow } = require('electron');
+
+const DAUER_MS = 280;
+const HOECHSTENS_MS = 2000; // spätestens dann ist das Fenster in jedem Fall zu sehen
+const warte = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function vereinigung(a, b) {
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  return {
+    x, y,
+    width: Math.max(a.x + a.width, b.x + b.width) - x,
+    height: Math.max(a.y + a.height, b.y + b.height) - y,
+  };
+}
+
+// Rechteck in Koordinaten des Hilfsfensters umrechnen
+const relativ = (r, box) => ({ x: r.x - box.x, y: r.y - box.y, width: r.width, height: r.height });
+
+async function abspielen(ziel, von, merke) {
+  // unsichtbar zeigen, damit Chromium den Inhalt zeichnet, dann abfotografieren
+  ziel.setOpacity(0);
+  ziel.setIgnoreMouseEvents(true);
+  ziel.show();
+  await warte(90);
+  if (ziel.isDestroyed()) return;
+  const bild = await ziel.webContents.capturePage();
+  if (bild.isEmpty() || ziel.isDestroyed()) return;
+  const nach = ziel.getBounds();
+  const box = vereinigung(von, nach);
+
+  const hilfe = new BrowserWindow({
+    x: box.x, y: box.y, width: box.width, height: box.height,
+    show: false, frame: false, transparent: true, resizable: false, movable: false,
+    minimizable: false, maximizable: false, fullscreenable: false, focusable: false,
+    skipTaskbar: true, hasShadow: false, alwaysOnTop: true, backgroundColor: '#00000000',
+    title: 'AeroMC',
+    webPreferences: { contextIsolation: true, nodeIntegration: false, sandbox: true },
+  });
+  merke(hilfe);
+  hilfe.setIgnoreMouseEvents(true);
+  await hilfe.loadFile(path.join(__dirname, 'aufbau.html'));
+  const ok = await hilfe.webContents.executeJavaScript(
+    `vorbereiten(${JSON.stringify(bild.toDataURL())}, ${JSON.stringify(relativ(nach, box))}, ${JSON.stringify(relativ(von, box))})`);
+  if (!ok || hilfe.isDestroyed()) return;
+  hilfe.showInactive();
+  await hilfe.webContents.executeJavaScript(`abspielen(${DAUER_MS})`);
+}
+
+/**
+ * Zeigt `ziel` (geladen, aber noch nicht sichtbar) mit Wachs-Animation an.
+ * `von` ist das Rechteck des angeklickten Knopfs in Bildschirmkoordinaten.
+ */
+async function wachsen(ziel, von) {
+  let hilfe = null;
+  try {
+    await Promise.race([abspielen(ziel, von, (h) => { hilfe = h; }), warte(HOECHSTENS_MS)]);
+  } catch {
+    // Animation ist nur Zierde – im Fehlerfall das Fenster einfach zeigen
+  } finally {
+    if (!ziel.isDestroyed()) {
+      ziel.setOpacity(1);
+      ziel.setIgnoreMouseEvents(false);
+      if (!ziel.isVisible()) ziel.show();
+      ziel.focus();
+    }
+    // Hilfsfenster erst nach dem Umschalten schließen, sonst blitzt der Hintergrund durch
+    setTimeout(() => { if (hilfe && !hilfe.isDestroyed()) hilfe.destroy(); }, 60);
+  }
+}
+
+module.exports = { wachsen };

src/friends.js

@@ -200,7 +200,32 @@ async function sendReport(daten) {
   }
 }
 
+// ---------- AeroMC-Umhänge ----------
+// Hochladen/Entfernen nur angemeldet; Abrufen ist öffentlich (auch für den Mod)
+function uploadCape(uuid, image) {
+  return anfrage('/cape', { method: 'POST', body: { uuid, image } });
+}
+
+function removeCape(uuid) {
+  return anfrage('/cape/remove', { method: 'POST', body: { uuid } });
+}
+
+async function getCapes(uuids) {
+  try {
+    const liste = [...new Set((uuids || []).map((u) => String(u).replace(/-/g, '').toLowerCase()))].filter(Boolean);
+    if (!liste.length) return { ok: true, capes: {} };
+    const { res, daten } = await roheAnfrage('/capes', { method: 'GET', body: { uuids: liste.join(',') } });
+    // ältere Plugin-Fassung ohne Umhänge
+    if (res.status === 404) return { ok: false, fehlt: true, message: 'Der Server kennt noch keine Umhänge (Plugin „AeroMC Freunde“ 1.5.0 nötig).' };
+    if (!res.ok) return { ok: false, message: (daten && daten.message) || `Fehler ${res.status}` };
+    return { ok: true, capes: (daten && daten.capes) || {} };
+  } catch (err) {
+    return { ok: false, message: 'Umhang-Server nicht erreichbar: ' + err.message };
+  }
+}
+
 module.exports = {
+  BASIS_URL, uploadCape, removeCape, getCapes,
   heartbeat, getFriends, getRequests, getSentRequests, sendRequest, respond, cancelRequest, removeFriend,
   sendInvite, getInvites, dismissInvite, createShare, getShare, setzeZugangsHelfer,
   sendMessage, getMessages, getUnreadMessages, markMessagesRead, sendReport,

src/garderobe.js

@@ -0,0 +1,106 @@
+/*
+ * Garderobe: gespeicherte Skins und Umhänge zum schnellen Wechseln.
+ *
+ * Mojang merkt sich keine früheren Skins – wer einen neuen hochlädt, verliert
+ * den alten. Die Garderobe hält Skins (samt Armform) und eigene AeroMC-Umhänge
+ * als PNG-Dateien im Launcher-Datenordner fest; vor jedem Skinwechsel im
+ * Launcher wird der bisherige Skin automatisch gesichert. Gleiche Dateien
+ * (gleiche Prüfsumme) werden nicht doppelt abgelegt.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const MAX_AUTOMATISCH = 20;   // ältere automatische Sicherungen fliegen raus
+let ordner = null;
+
+function init(userDataDir) {
+  ordner = path.join(userDataDir, 'garderobe');
+}
+
+const indexDatei = () => path.join(ordner, 'garderobe.json');
+function lies() {
+  try { return JSON.parse(fs.readFileSync(indexDatei(), 'utf8')); } catch { return []; }
+}
+function schreibe(liste) {
+  fs.mkdirSync(ordner, { recursive: true });
+  fs.writeFileSync(indexDatei(), JSON.stringify(liste, null, 1));
+}
+
+/** Alle Einträge, neueste zuerst, jeweils mit Bild als data:-Adresse. */
+function liste() {
+  return lies()
+    .filter((e) => fs.existsSync(path.join(ordner, e.datei)))
+    .sort((a, b) => String(b.erstellt).localeCompare(String(a.erstellt)))
+    .map((e) => Object.assign({}, e, {
+      dataUri: 'data:image/png;base64,' + fs.readFileSync(path.join(ordner, e.datei)).toString('base64'),
+    }));
+}
+
+/**
+ * Legt einen Skin/Umhang ab. art: 'skin' | 'umhang', daten: PNG-Buffer.
+ * Gibt es dieselbe Datei schon, wird nur ggf. aus "automatisch" ein fester Eintrag.
+ */
+function hinzufuegen({ art, daten, name, variante, automatisch }) {
+  const hash = crypto.createHash('sha1').update(daten).digest('hex');
+  const eintraege = lies();
+  const vorhanden = eintraege.find((e) => e.art === art && e.hash === hash);
+  if (vorhanden) {
+    if (!automatisch && vorhanden.automatisch) {
+      vorhanden.automatisch = false;
+      if (name) vorhanden.name = name;
+      schreibe(eintraege);
+    }
+    return { eintrag: vorhanden, neu: false };
+  }
+  fs.mkdirSync(ordner, { recursive: true });
+  const id = Date.now().toString(36) + crypto.randomBytes(3).toString('hex');
+  const datei = `${art}-${id}.png`;
+  fs.writeFileSync(path.join(ordner, datei), daten);
+  const eintrag = {
+    id, art, hash, datei,
+    name: String(name || '').trim().slice(0, 40) || (art === 'skin' ? 'Skin' : 'Umhang'),
+    variante: art === 'skin' ? (variante === 'slim' ? 'slim' : 'classic') : undefined,
+    automatisch: !!automatisch,
+    erstellt: new Date().toISOString(),
+  };
+  eintraege.push(eintrag);
+  // automatische Sicherungen begrenzen (feste Einträge bleiben immer)
+  const auto = eintraege.filter((e) => e.automatisch).sort((a, b) => String(b.erstellt).localeCompare(String(a.erstellt)));
+  for (const alt of auto.slice(MAX_AUTOMATISCH)) loescheIntern(eintraege, alt.id);
+  schreibe(eintraege);
+  return { eintrag, neu: true };
+}
+
+function loescheIntern(eintraege, id) {
+  const i = eintraege.findIndex((e) => e.id === id);
+  if (i < 0) return false;
+  try { fs.unlinkSync(path.join(ordner, eintraege[i].datei)); } catch { /* schon weg */ }
+  eintraege.splice(i, 1);
+  return true;
+}
+
+function loeschen(id) {
+  const eintraege = lies();
+  const ok = loescheIntern(eintraege, id);
+  if (ok) schreibe(eintraege);
+  return ok;
+}
+
+function umbenennen(id, name) {
+  const eintraege = lies();
+  const e = eintraege.find((x) => x.id === id);
+  if (!e) return false;
+  e.name = String(name || '').trim().slice(0, 40) || e.name;
+  e.automatisch = false;   // umbenannt = bewusst behalten
+  schreibe(eintraege);
+  return true;
+}
+
+/** Eintrag samt Dateipfad (zum Anziehen). */
+function holen(id) {
+  const e = lies().find((x) => x.id === id);
+  return e ? Object.assign({}, e, { pfad: path.join(ordner, e.datei) }) : null;
+}
+
+module.exports = { init, liste, hinzufuegen, loeschen, umbenennen, holen };

src/index.html

@@ -27,16 +27,19 @@
     <button id="btn-stats" class="tbtn" data-ic="chart" title="Spielzeit-Statistik">Statistik</button>
     <button id="btn-friends" class="tbtn" data-ic="users" title="Freunde (ingame: Strg+Alt+F zeigt, wer online ist)">Freunde<span id="friends-badge" class="tb-badge hidden"></span></button>
     <span class="tbgrow"></span>
-    <div class="search-wrap">
+    <div id="search-wrap" class="search-wrap">
-      <input id="search" type="text" placeholder="Suchen… (Strg+F)" autocomplete="off" title="Strg+F fokussiert die Suche" />
+      <button id="btn-search" class="tbtn tb-lupe" data-ic="search" title="Instanzen suchen (Strg+F)"></button>
+      <input id="search" type="text" placeholder="Suchen… (Esc schließt)" autocomplete="off" title="Instanzen nach Name, Version oder Gruppe filtern" />
     </div>
-    <button id="btn-account" class="tbtn acct-btn" title="Microsoft-Konto"><span id="account-av" class="acct-av"></span><span id="account-name">Konten</span></button>
+    <button id="btn-account" class="tbtn acct-btn" title="Konto wechseln, hinzufügen oder verwalten"><span id="account-av" class="acct-av"></span><span id="account-name">Konten</span><span class="acct-pfeil">▾</span></button>
     <button id="btn-settings" class="tbtn" data-ic="settings" title="Einstellungen">Optionen</button>
   </header>
 
   <!-- Arbeitsbereich: Instanzliste + rechte Aktionsleiste -->
   <main class="workspace">
     <div class="list-area">
+      <div id="lichtpunkte" class="lichtpunkte" aria-hidden="true"></div>
+      <canvas id="skin-live" class="skin-live hidden"></canvas>
       <div id="grid" class="list"></div>
       <section id="empty" class="empty hidden">
         <h2>Noch keine Instanzen</h2>
@@ -51,8 +54,15 @@
         <div id="p-icon" class="side-ico">🌱</div>
         <div id="p-name" class="side-title">Instanz</div>
         <div id="p-groupline" class="side-grp">Gruppe ändern</div>
+        <div id="p-gesperrt" class="side-gesperrt hidden">
+          <div class="side-gesperrt-titel"><img src="assets/verbot.svg" alt="" /> Instanz gesperrt</div>
+          <div class="side-gesperrt-text">Diese Instanz wurde außerhalb des Launchers verändert und kann nicht mehr gestartet werden.</div>
+          <ul id="p-gesperrt-gruende" class="side-gesperrt-gruende"></ul>
+          <button id="p-wiederherstellen" class="sbtn play">Aus Sicherung wiederherstellen</button>
+          <div class="side-gesperrt-text dim">Die Wiederherstellung wird als neue Instanz angelegt. Die gesperrte bleibt erhalten, bis du sie selbst löschst.</div>
+        </div>
         <div class="hr"></div>
-        <button id="p-play" class="sbtn play">Starten</button>
+        <button id="p-play" class="sbtn play"><span class="play-text">Starten</span></button>
         <button id="p-offline" class="sbtn">Offline starten</button>
         <div class="hr"></div>
         <button id="p-edit" class="sbtn">Instanz bearbeiten</button>
@@ -105,6 +115,7 @@
           <span>Gruppe <small class="opt">(optional)</small></span>
           <input id="f-group" type="text" list="group-list" placeholder="z. B. Modpacks, Server, Tests" autocomplete="off" />
           <datalist id="group-list"></datalist>
+          <small class="hint">Untergruppe: mit „/“ trennen, z. B. „Modpacks/Survival“.</small>
         </label>
 
         <div class="field-row">
@@ -243,87 +254,62 @@
           <button class="snav on" data-pane="pane-general">Allgemein</button>
           <button class="snav" data-pane="pane-appearance">Darstellung</button>
           <button class="snav" data-pane="pane-minecraft">Spiel</button>
-          <button class="snav" data-pane="pane-start">Start &amp; Java</button>
+          <button class="snav" data-pane="pane-start">Java &amp; Erweitert</button>
+          <button class="snav" data-pane="pane-online">Freunde &amp; Umhänge</button>
           <button class="snav" data-pane="pane-network">Netzwerk</button>
           <button class="snav" data-pane="pane-accounts">Konten</button>
           <button class="snav" data-pane="pane-backup">Backup</button>
           <button class="snav" data-pane="pane-info">Info</button>
         </nav>
         <div class="settings-content">
+          <!-- Aufbau: jede Karte enthält Zeilen – links Name + kurze Erklärung, rechts das Bedienelement -->
           <div id="pane-general" class="spane">
             <div class="settings-hero">
               <h4>Allgemein</h4>
-              <p>Globale Launcher-Optionen, Instanzverwaltung und sichtbare Bereiche.</p>
+              <p>Wie sich der Launcher verhält und wo deine Instanzen liegen.</p>
             </div>
             <div class="settings-grid">
               <section class="settings-card">
-                <h5>Instanzliste</h5>
+                <h5>Launcher</h5>
-                <label class="field">
+                <div class="s-zeile">
-                  <span>Instanzen sortieren</span>
+                  <div class="s-text"><b>Mit Windows starten</b><small>Startet AeroMC beim Anmelden im Infobereich neben der Uhr. Solange aktiv, schließt das X den Launcher nicht, sondern legt ihn dort ab.</small></div>
-                  <select id="s-sortby">
+                  <label class="schalter"><input id="s-autostart" type="checkbox" /><i></i></label>
-                    <option value="lastPlayed">Nach letztem Start</option>
+                </div>
-                    <option value="name">Nach Name</option>
+                <div class="s-zeile">
-                  </select>
+                  <div class="s-text"><b>Windows-Benachrichtigungen</b><small>Meldet, wenn ein großer Download oder ein Backup im Hintergrund fertig ist – nur, solange der Launcher nicht im Vordergrund ist.</small></div>
-                </label>
+                  <label class="schalter"><input id="s-notify" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Bedrock-Bereich anzeigen</b><small id="s-bedrock-hint">Wird automatisch ausgeblendet, wenn Bedrock nicht installiert ist.</small></div>
+                  <label class="schalter"><input id="s-bedrock" type="checkbox" /><i></i></label>
+                </div>
               </section>
-
+              <section class="settings-card">
-              <section class="settings-card settings-card-wide">
                 <h5>Instanzen</h5>
-                <label class="field">
+                <div class="s-zeile s-voll">
-                  <span>Instanz-Verzeichnis</span>
+                  <div class="s-text"><b>Instanz-Verzeichnis</b><small>Jede Instanz liegt hier als Unterordner mit ihrem Namen.</small></div>
                   <div class="path-row">
                     <input id="s-instances-dir" type="text" readonly />
                     <button id="s-pick-dir" class="btn">Wählen…</button>
                   </div>
-                  <small class="hint">Hier werden alle Instanzen als Unterordner mit ihrem Namen gespeichert.</small>
+                </div>
-                </label>
+                <div class="s-zeile">
-              </section>
+                  <div class="s-text"><b>Sortierung</b><small>Reihenfolge der Instanzen in der Übersicht.</small></div>
-
+                  <select id="s-sortby" class="s-wert">
-              <section class="settings-card">
+                    <option value="lastPlayed">Nach letztem Start</option>
-                <h5>Bereiche</h5>
+                    <option value="name">Nach Name</option>
-                <label class="checkbox-field">
+                  </select>
-                  <input id="s-bedrock" type="checkbox" /> <span>Bedrock-Bereich anzeigen</span>
+                </div>
-                </label>
-                <small id="s-bedrock-hint" class="hint">Wird automatisch ausgeblendet, wenn Bedrock nicht installiert ist.</small>
-              </section>
-
-              <section class="settings-card">
-                <h5>Benachrichtigungen</h5>
-                <label class="checkbox-field">
-                  <input id="s-notify" type="checkbox" /> <span>Windows-Benachrichtigung, wenn ein großer Download oder ein Backup im Hintergrund fertig wird</span>
-                </label>
-                <small class="hint">Erscheint nur, während das Launcher-Fenster nicht im Vordergrund ist.</small>
-              </section>
-
-              <section class="settings-card">
-                <h5>Freundesystem</h5>
-                <label class="checkbox-field">
-                  <input id="s-friends" type="checkbox" /> <span>Freundesystem aktivieren</span>
-                </label>
-                <small class="hint">Ausgeschaltet: du bist für niemanden sichtbar und kannst von niemandem als Freund gefunden/hinzugefügt werden. Bestehende Freundschaften bleiben erhalten, zeigen dich aber als offline.</small>
-                <label class="checkbox-field" style="margin-top:10px">
-                  <input id="s-friends-server" type="checkbox" /> <span>Server, auf dem ich spiele, für Freunde sichtbar</span>
-                </label>
-                <small class="hint">Ausgeschaltet sehen Freunde nur, dass du spielst – nicht wo. „Beitreten“ ist dann bei dir nicht möglich, Einladungen kannst du aber weiterhin verschicken.</small>
-              </section>
-
-              <section class="settings-card">
-                <h5>Autostart</h5>
-                <label class="checkbox-field">
-                  <input id="s-autostart" type="checkbox" /> <span>Mit Windows starten (im Infobereich)</span>
-                </label>
-                <small class="hint">Startet AeroMC beim Anmelden automatisch im Hintergrund. Solange aktiv, landet der Launcher beim Schließen (X) nur im Infobereich neben der Uhr, statt sich zu beenden – über das Symbol dort lässt er sich jederzeit wieder öffnen oder wirklich beenden.</small>
               </section>
             </div>
           </div>
-
           <div id="pane-appearance" class="spane hidden">
             <div class="settings-hero">
               <h4>Darstellung</h4>
-              <p>Optik der Oberfläche und visuelle Extras für die Instanzansicht.</p>
+              <p>Design, Bewegung und der Skin im Hintergrund.</p>
             </div>
             <div class="settings-grid">
-              <section class="settings-card settings-card-wide">
+              <section class="settings-card">
                 <h5>Design</h5>
                 <div class="field">
                   <select id="s-theme" class="hidden">
@@ -353,25 +339,30 @@
                 </div>
                 <small class="hint">Ein Klick zeigt das Design sofort an – mit „Speichern“ gilt es in allen Fenstern.</small>
               </section>
-
               <section class="settings-card">
-                <h5>Icons</h5>
+                <h5>Bewegung &amp; Effekte</h5>
-                <label class="checkbox-field">
+                <div class="s-zeile">
-                  <input id="s-iso3d" type="checkbox" /> <span>Block-Symbole räumlich darstellen (3D)</span>
+                  <div class="s-text"><b>Startanimation</b><small>Das Logo dreht sich, danach baut sich das Fenster von der Mitte aus auf. Gilt ab dem nächsten Start.</small></div>
-                </label>
+                  <label class="schalter"><input id="s-start-animation" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Bewegte Oberfläche</b><small>Die Skin-Figur atmet und schaut zum Mauszeiger, Fenster wachsen aus dem Knopf, Designs blenden weich über.</small></div>
+                  <label class="schalter"><input id="s-ui-animationen" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Räumliche Block-Symbole</b><small>Zeigt die Block-Symbole der Instanzen in 3D.</small></div>
+                  <label class="schalter"><input id="s-iso3d" type="checkbox" /><i></i></label>
+                </div>
               </section>
-
+              <section class="settings-card">
-              <section class="settings-card settings-card-wide">
                 <h5>Skin-Hintergrund</h5>
-                <label class="field">
+                <div class="s-zeile">
-                  <span>Quelle <small class="opt">(optional)</small></span>
+                  <div class="s-text"><b>Quelle</b><small>Zeigt den Skin eines Kontos groß im Instanzbereich.</small></div>
-                  <select id="s-bgskin"><option value="">Aus</option></select>
+                  <select id="s-bgskin" class="s-wert"><option value="">Aus</option></select>
-                  <small class="hint">Zeigt den Minecraft-Skin des gewählten Kontos als Hintergrund im Instanzbereich.</small>
+                </div>
-                </label>
+                <div class="s-zeile">
-                <div class="field-row">
+                  <div class="s-text"><b>Pose</b></div>
-                  <label class="field">
+                  <select id="s-bgskin-pose" class="s-wert">
-                    <span>Pose</span>
-                    <select id="s-bgskin-pose">
                     <option value="walking">Laufend</option>
                     <option value="standing">Stehend</option>
                     <option value="legends">Heldenhaft</option>
@@ -380,84 +371,100 @@
                     <option value="sitting">Sitzend</option>
                     <option value="spooky">Unheimlich</option>
                   </select>
-                  </label>
+                </div>
-                  <label class="field">
+                <div class="s-zeile">
-                    <span>Armform</span>
+                  <div class="s-text"><b>Armform</b><small>„Automatisch“ übernimmt die Einstellung des Kontos.</small></div>
-                    <select id="s-bgskin-model" title="Bei „Automatisch“ wird die Armform übernommen, die beim Konto eingestellt ist">
+                  <select id="s-bgskin-model" class="s-wert">
                     <option value="auto">Automatisch (vom Konto)</option>
                     <option value="classic">Normal (breite Arme, Steve)</option>
                     <option value="slim">Schmal (Alex)</option>
                   </select>
-                  </label>
-                  <label class="field">
-                    <span>Deckkraft: <span id="s-bgskin-val">55</span> %</span>
-                    <input id="s-bgskin-opacity" type="range" min="10" max="100" step="5" />
-                  </label>
                 </div>
-                <label class="checkbox-field">
+                <div class="s-zeile">
-                  <input id="s-bgskin-cycle" type="checkbox" /> <span>Bei mehreren angemeldeten Konten automatisch durchwechseln</span>
+                  <div class="s-text"><b>Deckkraft</b></div>
-                </label>
+                  <div class="s-wert s-regler"><input id="s-bgskin-opacity" type="range" min="10" max="100" step="5" /><span><span id="s-bgskin-val">55</span> %</span></div>
-                <label class="field">
+                </div>
-                  <span>Wechsel alle <small class="opt">(Sekunden)</small></span>
+                <div class="s-zeile">
-                  <input id="s-bgskin-cycle-seconds" type="number" min="5" step="5" />
+                  <div class="s-text"><b>Konten durchwechseln</b><small>Bei 2 oder mehr angemeldeten Konten wechselt der Skin der Reihe nach.</small></div>
-                  <small class="hint">Läuft nur, wenn 2 oder mehr Konten angemeldet sind, und beginnt nach dem letzten Konto wieder von vorn.</small>
+                  <label class="schalter"><input id="s-bgskin-cycle" type="checkbox" /><i></i></label>
-                </label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Wechsel alle</b></div>
+                  <div class="s-wert s-einheit"><input id="s-bgskin-cycle-seconds" type="number" min="5" step="5" /><span>Sekunden</span></div>
+                </div>
               </section>
             </div>
           </div>
-
           <div id="pane-minecraft" class="spane hidden">
             <div class="settings-hero">
               <h4>Spiel</h4>
-              <p>Standardwerte für neue und bestehende Instanzen ohne eigene Überschreibung.</p>
+              <p>Standardwerte für alle Instanzen ohne eigene Einstellung – und was beim Spielen passiert.</p>
             </div>
             <div class="settings-grid">
               <section class="settings-card">
-                <h5>Speicher</h5>
+                <h5>Leistung &amp; Fenster</h5>
-                <div class="field-row">
+                <div class="s-zeile">
-                  <label class="field">
+                  <div class="s-text"><b>Arbeitsspeicher</b><small>Mindestens / höchstens, in MB.</small></div>
-                    <span>Standard-RAM min. (MB)</span>
+                  <div class="s-wert s-paar"><input id="s-min-mem" type="number" min="512" step="256" aria-label="RAM min. (MB)" /><span>–</span><input id="s-max-mem" type="number" min="512" step="256" aria-label="RAM max. (MB)" /></div>
-                    <input id="s-min-mem" type="number" min="512" step="256" />
+                </div>
-                  </label>
+                <div class="s-zeile">
-                  <label class="field">
+                  <div class="s-text"><b>Maximiert starten</b><small>Minecraft öffnet sich bildschirmfüllend.</small></div>
-                    <span>Standard-RAM max. (MB)</span>
+                  <label class="schalter"><input id="s-mc-max" type="checkbox" /><i></i></label>
-                    <input id="s-max-mem" type="number" min="512" step="256" />
+                </div>
-                  </label>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Fenstergröße</b><small>Breite × Höhe, wenn nicht maximiert.</small></div>
+                  <div class="s-wert s-paar"><input id="s-mc-width" type="number" min="320" step="10" aria-label="Fensterbreite" /><span>×</span><input id="s-mc-height" type="number" min="240" step="10" aria-label="Fensterhöhe" /></div>
                 </div>
-                <small class="hint">Gilt für alle Instanzen ohne eigene RAM-Einstellung.</small>
               </section>
-
               <section class="settings-card">
-                <h5>Fenster</h5>
+                <h5>AeroMC-Look</h5>
-                <label class="checkbox-field">
+                <div class="s-zeile">
-                  <input id="s-mc-max" type="checkbox" /> <span>Minecraft maximiert starten</span>
+                  <div class="s-text"><b>AeroMC-Look im Spiel</b><small>Ladebildschirm und Hauptmenü im AeroMC-Look: Landschaftsbild, großes AeroMC-Logo, Knöpfe mit Symbolen und eigene Sprüche, dazu Fenstertitel und -symbol. Ab Minecraft 1.14, gilt ab dem nächsten Start – eigene Ressourcenpakete haben Vorrang.</small></div>
-                </label>
+                  <label class="schalter"><input id="s-aeromc-design" type="checkbox" /><i></i></label>
-                <div class="field-row">
-                  <label class="field"><span>Fensterbreite</span><input id="s-mc-width" type="number" min="320" step="10" /></label>
-                  <label class="field"><span>Fensterhöhe</span><input id="s-mc-height" type="number" min="240" step="10" /></label>
                 </div>
               </section>
-
               <section class="settings-card">
                 <h5>Mods</h5>
-                <label class="checkbox-field">
+                <div class="s-zeile">
-                  <input id="s-auto-mod-updates" type="checkbox" /> <span>Vor jedem Start nach Mod-Updates suchen und installieren</span>
+                  <div class="s-text"><b>Mod-Updates vor dem Start</b><small>Sucht vor jedem Start nach Updates für Modrinth-Mods und installiert sie. Nach 20 Sekunden startet Minecraft ohne Update; abgeschaltete Mods bleiben aus.</small></div>
-                </label>
+                  <label class="schalter"><input id="s-auto-mod-updates" type="checkbox" /><i></i></label>
-                <small class="hint">Gilt für Mods aus Modrinth. Dauert die Suche länger als 20 Sekunden, startet Minecraft ohne Update. Abgeschaltete Mods bleiben abgeschaltet.</small>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Mods im Spiel verwalten</b><small>Im Pausemenü wird „Feedback geben“ zu „Mods verwalten“: Mods per Klick zwischen „Aktiv“ und „Deaktiviert“ verschieben. Das Spiel läuft weiter, die Änderung gilt ab dem nächsten Start (oder direkt mit „Übernehmen &amp; neu starten“). Nur Instanzen mit Mod-Loader.</small></div>
+                  <label class="schalter"><input id="s-mod-schalter" type="checkbox" /><i></i></label>
+                </div>
+              </section>
+              <section class="settings-card">
+                <h5>Konsole</h5>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Während des Spiels anzeigen</b></div>
+                  <label class="schalter"><input id="s-console-launch" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Nach dem Beenden schließen</b></div>
+                  <label class="schalter"><input id="s-console-autoclose" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Bei einem Absturz anzeigen</b></div>
+                  <label class="schalter"><input id="s-console-crash" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Zeilen merken</b><small>Ältere Zeilen fallen aus der Konsole heraus.</small></div>
+                  <input id="s-console-lines" class="s-wert s-zahl" type="number" min="1000" step="1000" />
+                </div>
               </section>
             </div>
           </div>
-
           <div id="pane-start" class="spane hidden">
             <div class="settings-hero">
-              <h4>Start &amp; Java</h4>
+              <h4>Java &amp; Erweitert</h4>
-              <p>Runtime-Auswahl, Startverhalten und globale Befehle für alle Instanzen.</p>
+              <p>Welches Java startet und was zusätzlich vor oder nach dem Spiel läuft.</p>
             </div>
-            <div class="settings-grid settings-grid-stack">
+            <div class="settings-grid">
-              <section class="settings-card settings-card-wide">
+              <section class="settings-card">
                 <h5>Java</h5>
-                <label class="field">
+                <div class="s-zeile s-voll">
-                  <span>Java (java.exe)</span>
+                  <div class="s-text"><b>Java-Programm</b><small id="s-java-status">–</small></div>
                   <div class="path-row">
                     <input id="s-java" type="text" placeholder="leer = java aus PATH" />
                     <button id="s-pick-java" class="btn">Wählen…</button>
@@ -466,66 +473,69 @@
                     <select id="s-java-detected"><option value="">– gefundene Java-Installationen –</option></select>
                     <button id="s-scan-java" class="btn">Erkennen</button>
                   </div>
-                  <small id="s-java-status" class="hint">–</small>
+                </div>
-                </label>
+                <div class="s-zeile">
-                <label class="checkbox-field">
+                  <div class="s-text"><b>Fehlendes Java herunterladen</b><small>Holt beim Start die passende Version von Eclipse Temurin, wenn keine geeignete gefunden wird (rund 45 MB je Version).</small></div>
-                  <input id="s-auto-java" type="checkbox" /> <span>Fehlende Java-Version automatisch herunterladen</span>
+                  <label class="schalter"><input id="s-auto-java" type="checkbox" /><i></i></label>
-                </label>
+                </div>
-                <small class="hint">Holt beim Spielstart die passende Fassung von Eclipse Temurin, wenn keine geeignete Java-Installation gefunden wird. Ablage im Launcher-Ordner, rund 45 MB je Version.</small>
               </section>
-
               <section class="settings-card">
-                <h5>Konsole</h5>
+                <h5>Befehle</h5>
-                <label class="checkbox-field">
+                <small class="hint s-vorab">Für Fortgeschrittene. Befehle aus dem Bearbeiten-Dialog einer Instanz haben Vorrang.</small>
-                  <input id="s-console-launch" type="checkbox" /> <span>Konsole anzeigen, während das Spiel läuft</span>
+                <div class="s-zeile">
-                </label>
+                  <div class="s-text"><b>Vor dem Start</b></div>
-                <label class="checkbox-field">
+                  <input id="s-global-pre" class="s-wert s-breit" type="text" placeholder="läuft vor jedem Spielstart" />
-                  <input id="s-console-autoclose" type="checkbox" /> <span>Konsole automatisch schließen, nachdem das Spiel beendet wurde</span>
+                </div>
-                </label>
+                <div class="s-zeile">
-                <label class="checkbox-field">
+                  <div class="s-text"><b>Nach dem Beenden</b></div>
-                  <input id="s-console-crash" type="checkbox" /> <span>Konsole anzeigen, wenn das Spiel abstürzt</span>
+                  <input id="s-global-post" class="s-wert s-breit" type="text" placeholder="läuft nach jedem Beenden" />
-                </label>
+                </div>
-                <label class="field">
+                <div class="s-zeile">
-                  <span>Historie-Limit (Zeilen)</span>
+                  <div class="s-text"><b>Wrapper</b><small>Startet Java über dieses Programm.</small></div>
-                  <input id="s-console-lines" type="number" min="1000" step="1000" />
+                  <input id="s-wrapper" class="s-wert s-breit" type="text" placeholder="z. B. prime-run" />
-                </label>
+                </div>
               </section>
-
+            </div>
+          </div>
+          <div id="pane-online" class="spane hidden">
+            <div class="settings-hero">
+              <h4>Freunde &amp; Umhänge</h4>
+              <p>Was andere AeroMC-Spieler von dir sehen.</p>
+            </div>
+            <div class="settings-grid">
               <section class="settings-card">
-                <h5>Globale Befehle</h5>
+                <h5>Freundesystem</h5>
-                <label class="field">
+                <div class="s-zeile">
-                  <span>Pre-Launch-Befehl</span>
+                  <div class="s-text"><b>Freundesystem aktivieren</b><small>Aus: niemand kann dich finden oder hinzufügen. Bestehende Freunde bleiben, sehen dich aber als offline.</small></div>
-                  <input id="s-global-pre" type="text" placeholder="läuft vor jedem Spielstart" />
+                  <label class="schalter"><input id="s-friends" type="checkbox" /><i></i></label>
-                </label>
+                </div>
-                <label class="field">
+                <div class="s-zeile">
-                  <span>Post-Exit-Befehl</span>
+                  <div class="s-text"><b>Server für Freunde sichtbar</b><small>Aus: Freunde sehen nur, dass du spielst, nicht wo – „Beitreten“ geht dann nicht, Einladungen schon.</small></div>
-                  <input id="s-global-post" type="text" placeholder="läuft nach jedem Beenden" />
+                  <label class="schalter"><input id="s-friends-server" type="checkbox" /><i></i></label>
-                </label>
+                </div>
-                <small class="hint">Instanzspezifische Befehle aus dem Bearbeiten-Dialog haben Vorrang.</small>
               </section>
-
+              <section class="settings-card">
-              <section class="settings-card settings-card-wide">
+                <h5>Umhänge</h5>
-                <h5>Externe Programme</h5>
+                <div class="s-zeile">
-                <label class="field">
+                  <div class="s-text"><b>AeroMC-Umhänge im Spiel</b><small>Zeigt deinen Umhang und den anderer AeroMC-Spieler – in jeder Version, mit jedem Loader, ohne Mod. Gestalten im Skin-Fenster unter „Umhang“. Gilt ab dem nächsten Start.</small></div>
-                  <span>Wrapper-Befehl</span>
+                  <label class="schalter"><input id="s-aeromc-capes" type="checkbox" /><i></i></label>
-                  <input id="s-wrapper" type="text" placeholder="z. B. prime-run (leer = kein Wrapper)" />
+                </div>
-                </label>
-                <small class="hint">Startet Java über dieses Programm. Java-Pfad und Argumente werden automatisch angehängt.</small>
               </section>
             </div>
           </div>
-
           <div id="pane-network" class="spane hidden">
             <div class="settings-hero">
               <h4>Netzwerk</h4>
-              <p>Verbindungsoptionen für Downloads und externe Dienste.</p>
+              <p>Proxy für Downloads und der Zugang zu CurseForge.</p>
             </div>
             <div class="settings-grid">
-              <section class="settings-card settings-card-wide">
+              <section class="settings-card">
                 <h5>Proxy</h5>
-                <label class="checkbox-field">
+                <div class="s-zeile">
-                  <input id="s-proxy-enabled" type="checkbox" /> <span>HTTP-Proxy für Downloads verwenden</span>
+                  <div class="s-text"><b>HTTP-Proxy verwenden</b><small>Nur nötig, wenn dein Netzwerk Downloads nur über einen Proxy erlaubt.</small></div>
-                </label>
+                  <label class="schalter"><input id="s-proxy-enabled" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-felder">
                   <div class="field-row">
                     <label class="field"><span>Host</span><input id="s-proxy-host" type="text" placeholder="proxy.firma.de" /></label>
                     <label class="field field-port"><span>Port</span><input id="s-proxy-port" type="text" placeholder="8080" /></label>
@@ -534,34 +544,29 @@
                     <label class="field"><span>Benutzer <small class="opt">(optional)</small></span><input id="s-proxy-user" type="text" /></label>
                     <label class="field"><span>Passwort <small class="opt">(optional)</small></span><input id="s-proxy-pass" type="password" /></label>
                   </div>
+                </div>
               </section>
-
+              <section class="settings-card">
-              <section class="settings-card settings-card-wide">
                 <h5>CurseForge</h5>
-                <label class="field">
+                <small class="hint s-vorab">Nur für CurseForge-Modpacks und -Mods nötig. Modrinth funktioniert immer ohne.</small>
-                  <span>Eigener API-Key <small class="opt">(optional)</small></span>
+                <div class="s-zeile s-voll">
+                  <div class="s-text"><b>Eigener API-Key</b><small>Von CurseForge for Studios (Profil → Schlüssel erstellen, beginnt mit cfc_pat_…) oder ein Organisationsschlüssel. Nach dem Eintragen speichern.</small></div>
                   <div class="path-row">
                     <input id="s-cf-key" type="password" placeholder="leer lassen, um die Weiterleitung unten zu nutzen" />
                     <button type="button" id="s-cf-test" class="btn">Prüfen</button>
                   </div>
-                  <small class="hint">Schlüssel von CurseForge for Studios (Profil → Schlüssel erstellen, beginnt mit cfc_pat_…) oder klassischer Organisationsschlüssel. Nach dem Eintragen speichern. „Prüfen“ testet den Key bei CurseForge.</small>
                   <small id="s-cf-test-status" class="hint"></small>
-                </label>
-                <div class="field-row">
-                  <label class="field">
-                    <span>Weiterleitung <small class="opt">(optional)</small></span>
-                    <input id="s-cf-proxy" type="text" placeholder="https://cf.example.de" />
-                  </label>
-                  <label class="field">
-                    <span>Token <small class="opt">(falls verlangt)</small></span>
-                    <input id="s-cf-proxy-token" type="password" />
-                  </label>
                 </div>
-                <small class="hint">Ein Server, der den Schlüssel für dich hält. Ohne beides funktionieren Modrinth-Modpacks (.mrpack) weiterhin.</small>
+                <div class="s-zeile s-voll">
+                  <div class="s-text"><b>Weiterleitung</b><small>Ein Server, der den Schlüssel für dich hält.</small></div>
+                  <div class="field-row">
+                    <label class="field"><span>Adresse</span><input id="s-cf-proxy" type="text" placeholder="https://cf.example.de" /></label>
+                    <label class="field"><span>Token <small class="opt">(falls verlangt)</small></span><input id="s-cf-proxy-token" type="password" /></label>
+                  </div>
+                </div>
               </section>
             </div>
           </div>
-
           <div id="pane-accounts" class="spane hidden">
             <div class="settings-hero">
               <h4>Konten</h4>
@@ -582,66 +587,58 @@
           <div id="pane-backup" class="spane hidden">
             <div class="settings-hero">
               <h4>Backup</h4>
-              <p>Alle Instanzen gesammelt als ZIP sichern, bevor größere Änderungen anstehen.</p>
+              <p>Sicherungen aller Instanzen und deiner Welten.</p>
             </div>
             <div class="settings-grid">
-              <section class="settings-card settings-card-wide">
+              <section class="settings-card">
-                <h5>Globales Backup</h5>
+                <h5>Jetzt sichern</h5>
-                <small class="hint">Backups werden automatisch unter Dokumente/AeroMC Launcher/Backups gespeichert. Instanzen und Launcher-Einstellungen werden gesichert. Konten und Tokens werden nicht mitgesichert.</small>
+                <div class="s-zeile">
-                <div class="path-row" style="margin-top:14px">
+                  <div class="s-text"><b>Komplett-Backup</b><small>Alle Instanzen und Launcher-Einstellungen als ZIP unter Dokumente\AeroMC Launcher\Backups. Konten und Anmeldedaten werden nicht gesichert.</small></div>
                   <button id="s-backup-global" class="btn btn-primary">Backup erstellen</button>
-                  <span id="s-backup-status" class="hint">Noch kein Backup erstellt.</span>
                 </div>
+                <small id="s-backup-status" class="hint s-status">Noch kein Backup erstellt.</small>
                 <div id="s-backup-progress" class="backup-progress hidden" aria-hidden="true">
                   <div class="backup-progress-bar"><div id="s-backup-progress-fill" class="backup-progress-fill"></div></div>
                   <div id="s-backup-progress-text" class="backup-progress-text hint">0 %</div>
                 </div>
               </section>
-
+              <section class="settings-card">
-              <section class="settings-card settings-card-wide">
                 <h5>Automatisch sichern</h5>
-                <label class="checkbox-field">
+                <div class="s-zeile">
-                  <input id="s-autobackup" type="checkbox" /> <span>Sicherungen nach Zeitplan erstellen</span>
+                  <div class="s-text"><b>Nach Zeitplan sichern</b><small id="s-autobackup-last">Noch keine automatische Sicherung.</small></div>
-                </label>
+                  <label class="schalter"><input id="s-autobackup" type="checkbox" /><i></i></label>
-                <div class="field-row">
+                </div>
-                  <label class="field">
+                <div class="s-zeile">
-                    <span>Wie oft</span>
+                  <div class="s-text"><b>Wie oft</b></div>
-                    <select id="s-autobackup-every">
+                  <select id="s-autobackup-every" class="s-wert">
                     <option value="daily">Täglich</option>
                     <option value="weekly">Wöchentlich</option>
                   </select>
-                  </label>
-                  <label class="field">
-                    <span>Wie viele behalten</span>
-                    <input id="s-autobackup-keep" type="number" min="1" max="50" />
-                  </label>
                 </div>
-                <label class="checkbox-field">
+                <div class="s-zeile">
-                  <input id="s-autobackup-launch" type="checkbox" /> <span>Zusätzlich vor jedem Spielstart sichern</span>
+                  <div class="s-text"><b>Wie viele behalten</b><small>Ältere automatische Sicherungen werden gelöscht.</small></div>
-                </label>
+                  <input id="s-autobackup-keep" class="s-wert s-zahl" type="number" min="1" max="50" />
-                <small class="hint">Eine Sicherung umfasst <em>alle</em> Instanzen und kann je nach Umfang einige Minuten dauern. Vor dem Spielstart wird sie abgewartet – der Start verzögert sich entsprechend. Ältere automatische Sicherungen werden gelöscht, sobald die eingestellte Anzahl überschritten ist.</small>
+                </div>
-                <small id="s-autobackup-last" class="hint">Noch keine automatische Sicherung.</small>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Zusätzlich vor jedem Start</b><small>Der Start wartet, bis die Sicherung fertig ist – bei vielen Instanzen kann das einige Minuten dauern.</small></div>
+                  <label class="schalter"><input id="s-autobackup-launch" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Welt nach dem Spielen sichern</b><small>Sichert nach jeder Sitzung die zuletzt gespielte Welt im Hintergrund. Je Welt bleiben die letzten 5 Stände (Dokumente\AeroMC Launcher\Welten-Sicherungen).</small></div>
+                  <label class="schalter"><input id="s-auto-world" type="checkbox" /><i></i></label>
+                </div>
               </section>
-
               <section class="settings-card">
-                <h5>Welten</h5>
-                <label class="checkbox-field">
-                  <input id="s-auto-world" type="checkbox" /> <span>Nach jeder Spielsitzung die zuletzt gespielte Welt sichern</span>
-                </label>
-                <small class="hint">Läuft im Hintergrund, sobald Minecraft beendet ist. Pro Welt bleiben die letzten 5 Stände erhalten – unter Dokumente\AeroMC Launcher\Welten-Sicherungen\&lt;Instanz&gt;\Automatisch.</small>
-              </section>
-
-              <section class="settings-card settings-card-wide">
                 <h5>Wiederherstellen</h5>
-                <small class="hint">Wähle ein Backup aus Dokumente/AeroMC Launcher/Backups aus. Achtung: Alle vorhandenen Instanzen werden beim Wiederherstellen mit dem Inhalt des Backups überschrieben. Launcher-Einstellungen werden ebenfalls wiederhergestellt. Konten und Tokens bleiben unverändert.</small>
+                <small class="hint s-vorab s-warnung">Achtung: Alle vorhandenen Instanzen und die Launcher-Einstellungen werden mit dem Inhalt des Backups überschrieben. Konten bleiben unverändert.</small>
-                <label class="field backup-select-field">
+                <div class="s-zeile s-voll">
-                  <span>Verfügbares Backup</span>
+                  <div class="s-text"><b>Verfügbares Backup</b></div>
+                  <div class="path-row">
                     <select id="s-restore-backup"></select>
-                </label>
+                    <button id="s-restore-global" class="btn">Wiederherstellen</button>
-                <div class="path-row" style="margin-top:14px">
-                  <button id="s-restore-global" class="btn">Backup wiederherstellen</button>
-                  <span id="s-restore-status" class="hint">Noch kein Backup wiederhergestellt.</span>
                   </div>
+                </div>
+                <small id="s-restore-status" class="hint s-status">Noch kein Backup wiederhergestellt.</small>
                 <div id="s-restore-progress" class="backup-progress hidden" aria-hidden="true">
                   <div class="backup-progress-bar"><div id="s-restore-progress-fill" class="backup-progress-fill"></div></div>
                   <div id="s-restore-progress-text" class="backup-progress-text hint">0 %</div>
@@ -649,7 +646,6 @@
               </section>
             </div>
           </div>
-
           <div id="pane-info" class="spane hidden">
             <div class="settings-hero">
               <h4>Info</h4>
@@ -679,6 +675,37 @@
     </div>
   </div>
 
+  <!-- ===================== Mod-Schalter (über dem laufenden Spiel) ===================== -->
+  <div id="modal-modschalter" class="modal hidden">
+    <div class="modal-card modal-lg">
+      <div class="modal-head">
+        <h3>Mods verwalten <span id="ms-instanz" class="ms-instanz"></span></h3>
+        <button class="modal-close" id="ms-x" title="Zurück ins Spiel">✕</button>
+      </div>
+      <div class="modal-body ms-body">
+        <div class="ms-kopf">
+          <input id="ms-suche" type="search" placeholder="Mods durchsuchen …" autocomplete="off" />
+          <span id="ms-hinweis" class="hint"></span>
+        </div>
+        <div class="ms-spalten">
+          <section class="ms-spalte">
+            <div class="ms-titel">Aktive Mods <span id="ms-zahl-an" class="group-count"></span></div>
+            <div id="ms-an" class="ms-liste" role="list"></div>
+          </section>
+          <section class="ms-spalte">
+            <div class="ms-titel">Deaktivierte Mods <span id="ms-zahl-aus" class="group-count"></span></div>
+            <div id="ms-aus" class="ms-liste" role="list"></div>
+          </section>
+        </div>
+      </div>
+      <div class="modal-foot">
+        <span id="ms-status" class="hint ms-status"></span>
+        <button class="btn" id="ms-fertig">Zurück ins Spiel</button>
+        <button class="btn btn-primary hidden" id="ms-neustart" title="Minecraft speichert, beendet sich und startet mit den neuen Mods direkt wieder – in derselben Welt bzw. auf demselben Server">Übernehmen &amp; neu starten</button>
+      </div>
+    </div>
+  </div>
+
   <!-- ===================== Dialog: Bestätigung ===================== -->
   <div id="modal-confirm" class="modal hidden">
     <div class="modal-card modal-sm">
@@ -799,6 +826,7 @@
       </div>
       <div class="modal-foot">
         <button id="m-open-folder" class="btn" data-ic="folder">mods-Ordner</button>
+        <button id="m-leistung" class="btn" title="Bewährte Performance-Mods passend zu Version und Loader installieren (Sodium, Lithium, FerriteCore …)">⚡ Leistungs-Paket</button>
         <div class="spacer"></div>
         <button class="btn" data-close>Schließen</button>
       </div>
@@ -1093,11 +1121,20 @@
         <button class="modal-close" data-close>✕</button>
       </div>
       <div class="modal-body">
+        <div class="mods-tabs stats-tabs">
+          <button class="mtab on" data-stats-reiter="spielzeit">Spielzeit</button>
+          <button class="mtab" data-stats-reiter="erfolge">Erfolge <span id="erfolge-zahl"></span></button>
+        </div>
+        <div id="stats-reiter-spielzeit">
           <div id="stats-tiles" class="stats-tiles"></div>
           <div class="friends-section-title">Spielzeit pro Instanz</div>
           <div id="stats-list" class="stats-list" role="list"></div>
           <p id="stats-unplayed" class="hint"></p>
         </div>
+        <div id="stats-reiter-erfolge" class="hidden">
+          <div id="erfolge-liste" class="erfolge-liste"></div>
+        </div>
+      </div>
       <div class="modal-foot">
         <div class="spacer"></div>
         <button class="btn" data-close>Schließen</button>
@@ -1114,7 +1151,8 @@
       </div>
       <div class="modal-body">
         <p id="friends-disabled-hint" class="hint hidden">Das Freundesystem ist ausgeschaltet – aktiviere es in den Einstellungen, um Freunde zu sehen oder hinzuzufügen.</p>
-        <div id="friends-content">
+        <div id="friends-content" class="freunde-raster">
+          <div class="freunde-spalte">
             <div class="field-row">
               <input id="friends-add-input" type="text" placeholder="Minecraft-Name…" maxlength="16" />
               <button id="friends-add-btn" class="btn btn-mini">Anfrage senden</button>
@@ -1122,6 +1160,12 @@
             <div id="friends-requests-box"></div>
             <div id="friends-list-box"></div>
           </div>
+          <!-- 3D-Figur des ausgewählten Freundes (Skin + Umhang), neben der Liste -->
+          <div id="freund-buehne" class="freund-buehne hidden">
+            <canvas id="freund-figur"></canvas>
+            <div class="freund-buehne-text"><b id="freund-buehne-name"></b><span id="freund-buehne-status"></span></div>
+          </div>
+        </div>
         <!-- Unterhaltung mit einem Freund -->
         <div id="friends-chat" class="friends-chat hidden">
           <div class="chat-head">
@@ -1220,6 +1264,10 @@
       </div>
       <div class="modal-body">
         <p id="skin-konto" class="hint">–</p>
+        <div id="skin-armform-hinweis" class="skin-armform-hinweis hidden">
+          <span id="skin-armform-text"></span>
+          <button id="skin-armform-fix" class="btn btn-mini btn-primary"></button>
+        </div>
         <div class="skin-vorschau">
           <div class="skin-spalte">
             <div class="skin-label">Aktuell</div>
@@ -1249,6 +1297,38 @@
           </select>
         </label>
         <p id="skin-status" class="hint"></p>
+        <div class="skin-umhang">
+          <div class="skin-label">Umhang</div>
+          <div class="field-row">
+            <label class="field">
+              <span>Offizieller Umhang <small class="opt">(im Spiel für alle sichtbar)</small></span>
+              <select id="skin-cape-offiziell" title="Nur Umhänge, die dein Konto bei Mojang besitzt">
+                <option value="">Kein Umhang</option>
+              </select>
+            </label>
+            <div class="field">
+              <span>AeroMC-Umhang <small class="opt">(eigener, auch HD)</small></span>
+              <div class="skin-umhang-aero">
+                <span id="skin-cape-aero" class="hint">–</span>
+                <button id="skin-cape-edit" class="btn btn-mini" title="Im Skin-Editor einen eigenen Umhang gestalten">Gestalten…</button>
+                <button id="skin-cape-remove" class="btn btn-mini btn-danger hidden">Entfernen</button>
+              </div>
+            </div>
+          </div>
+          <small id="skin-cape-status" class="hint">Den AeroMC-Umhang sehen im Spiel alle, die AeroMC nutzen oder den Mod „AeroMC Umhänge“ (Fabric/Quilt) installiert haben – dort hat er Vorrang vor dem offiziellen.</small>
+        </div>
+
+        <div class="skin-garderobe">
+          <div class="garderobe-kopf">
+            <div class="skin-label">Garderobe <small class="opt">(gespeicherte Skins und Umhänge – mit einem Klick wieder anziehen)</small></div>
+            <div class="garderobe-knoepfe">
+              <button id="gard-skin-speichern" class="btn btn-mini" title="Den Skin, den du gerade trägst, in der Garderobe ablegen">Aktuellen Skin speichern</button>
+              <button id="gard-umhang-speichern" class="btn btn-mini" title="Deinen eigenen AeroMC-Umhang in der Garderobe ablegen">Aktuellen Umhang speichern</button>
+            </div>
+          </div>
+          <div id="garderobe-liste" class="garderobe-liste"></div>
+          <small class="hint">Vor jedem Skinwechsel im Launcher wird der bisherige Skin automatisch hier gesichert – Mojang selbst merkt sich keine alten Skins.</small>
+        </div>
       </div>
       <div class="modal-foot">
         <button id="skin-reset" class="btn btn-danger">Auf Standard zurücksetzen</button>
@@ -1268,6 +1348,7 @@
         <div class="se-modus">
           <button class="se-modus-btn on" data-se-modus="2d" title="Auf der aufgeklappten Vorlage malen">2D-Vorlage</button>
           <button class="se-modus-btn" data-se-modus="3d" title="Direkt auf der drehbaren Figur malen">3D-Figur</button>
+          <button class="se-modus-btn" data-se-modus="umhang" title="Eigenen Umhang (auch HD) gestalten">Umhang</button>
         </div>
         <button class="modal-close" data-close>✕</button>
       </div>
@@ -1290,7 +1371,7 @@
             </div>
             <div id="se-zuletzt" class="se-zuletzt"></div>
           </div>
-          <div class="se-gruppe">
+          <div id="se-gruppe-ebene" class="se-gruppe">
             <div class="se-titel">Ebene</div>
             <div class="se-ebenen">
               <button class="se-ebene on" data-se-schicht="0" title="Die eigentliche Figur (L wechselt)">Grundschicht</button>
@@ -1300,6 +1381,30 @@
             <label class="se-check"><input id="se-durch" type="checkbox" checked /> Grundschicht durchscheinen</label>
             <button id="se-leeren" class="btn btn-mini">2. Schicht leeren</button>
           </div>
+          <div id="se-gruppe-umhang" class="se-gruppe hidden">
+            <div class="se-titel">Umhang</div>
+            <label class="se-feld"><span>Größe</span>
+              <select id="se-u-groesse" title="Größere Umhänge (HD) erlauben feinere Motive">
+                <option value="64">Normal (64×32)</option>
+                <option value="128">HD 128×64</option>
+                <option value="256">HD 256×128</option>
+                <option value="512">HD 512×256</option>
+                <option value="1024">HD 1024×512</option>
+              </select>
+            </label>
+            <label class="se-feld"><span>Pinselgröße</span>
+              <select id="se-u-pinsel">
+                <option value="1">1 Pixel</option>
+                <option value="2">2 Pixel</option>
+                <option value="4">4 Pixel</option>
+                <option value="8">8 Pixel</option>
+                <option value="16">16 Pixel</option>
+              </select>
+            </label>
+            <button id="se-u-bild" class="btn btn-mini" title="Ein beliebiges Bild (PNG, JPG …) auf die Außenseite setzen">Bild einsetzen…</button>
+            <label class="se-check" title="Dieselbe Datei trägt auch die Elytra"><input id="se-u-elytra" type="checkbox" /> Als Elytra zeigen</label>
+            <button id="se-u-einpassen" class="btn btn-mini" title="Zoom zurücksetzen (Taste 0)">Ansicht einpassen</button>
+          </div>
           <div class="se-gruppe">
             <div class="se-titel">Optionen</div>
             <label class="se-check" title="Malt gleichzeitig auf der anderen Körperseite (M)"><input id="se-spiegeln" type="checkbox" /> Spiegeln (links ↔ rechts)</label>
@@ -1319,6 +1424,10 @@
           <div id="se-buehne" class="se-buehne">
             <div id="se-2d" class="se-ansicht se-2d"><canvas id="se-2d-canvas"></canvas></div>
           </div>
+          <!-- gerade nicht gezeigte Ansichten (je nach Modus) -->
+          <div id="se-ablage" class="se-ablage">
+            <div id="se-u2d" class="se-ansicht se-u2d"><canvas id="se-u2d-canvas"></canvas></div>
+          </div>
           <div id="se-info" class="se-info hint"></div>
         </section>
         <aside class="se-seite">
@@ -1326,7 +1435,7 @@
           <div id="se-mini" class="se-mini">
             <div id="se-3d" class="se-ansicht se-3d"><canvas id="se-3d-canvas"></canvas><span id="se-3d-leer" class="hint se-3d-leer">wird geladen …</span></div>
           </div>
-          <p class="hint se-tipp">Beide Ansichten sind bemalbar. Die <b>2. Schicht</b> liegt wie eine Hülle über der Figur – lässt man Pixel darin frei, wirken Haare, Kapuzen oder Ärmel plastisch.</p>
+          <p id="se-tipp" class="hint se-tipp">Beide Ansichten sind bemalbar. Die <b>2. Schicht</b> liegt wie eine Hülle über der Figur – lässt man Pixel darin frei, wirken Haare, Kapuzen oder Ärmel plastisch.</p>
         </aside>
       </div>
       <div class="modal-foot se-fuss">
@@ -1490,6 +1599,16 @@
           <button id="import-tab-code" class="mtab" data-kind="code">Per Code</button>
         </div>
 
+        <div id="import-lauf" class="import-lauf hidden">
+          <div class="import-lauf-kopf">
+            <b id="import-lauf-titel">Wird vorbereitet …</b>
+            <button id="import-lauf-abbrechen" class="btn btn-mini btn-danger" title="Bricht den Import ab – die gerade halb kopierte Instanz wird wieder entfernt, fertig übernommene bleiben">Abbrechen</button>
+          </div>
+          <div class="import-balken"><i id="import-lauf-balken"></i></div>
+          <div id="import-lauf-zeile" class="import-lauf-zeile"></div>
+          <div id="import-lauf-datei" class="hint import-lauf-datei"></div>
+        </div>
+
         <div id="import-pane-zip" class="import-pane">
           <p class="import-copy">Importiert eine einzelne Instanz aus einem ZIP-Archiv.</p>
           <p class="hint">Erkannt werden AeroMC-Exporte (instance.json) und einzelne MultiMC- oder Prism-Instanzen (instance.cfg) – letztere auch als gezippter Instanzordner. Der Launcher legt daraus automatisch eine neue Instanz an, samt Mods, Welten und Konfiguration.</p>
@@ -1770,6 +1889,12 @@
     </div>
   </div>
 
+  <!-- Erfolg-Meldungen im Minecraft-Stil (oben rechts) -->
+  <div id="erfolg-meldungen" class="erfolg-meldungen"></div>
+
+  <!-- Konto-Menü (Klick auf den Kontoknopf oben rechts) -->
+  <div id="konto-menu" class="ctx konto-menu hidden" role="menu"></div>
+
   <div id="ctx-menu" class="ctx hidden">
     <button class="ctx-item" data-act="p-edit">Symbol ändern</button>
     <button class="ctx-item" data-act="p-edit">Umbenennen</button>

src/integritaet.js

@@ -0,0 +1,362 @@
+'use strict';
+
+/*
+ * integritaet.js – Manipulationsschutz für Instanzen
+ * --------------------------------------------------
+ * Für jede Instanz hält der Launcher ein "Siegel" fest:
+ *   - die Startdaten aus instance.json, mit denen sich Code ausführen ließe
+ *     (Java-Pfad, JVM-Argumente, Befehle vor dem Start / nach dem Beenden)
+ *   - den SHA-256 jeder Mod-Datei im mods-Ordner
+ * Das Siegel ist mit einem geheimen Schlüssel unterschrieben (HMAC), der per
+ * Windows-DPAPI verschlüsselt im Datenordner liegt.
+ *
+ * Als Manipulation gilt:
+ *   - eine bekannte Mod-Datei hat bei gleichem Namen einen anderen Inhalt
+ *     (so arbeitet Jar-infizierende Schadsoftware wie "Fractureiser")
+ *   - die Startdaten wurden außerhalb des Launchers geändert
+ *   - das Siegel selbst wurde verändert
+ * Keine Manipulation: neue, gelöschte, aktivierte oder deaktivierte Mods – das
+ * ist der normale Weg, Mods per Explorer hinzuzufügen oder zu entfernen.
+ *
+ * Eine manipulierte Instanz wird gesperrt: Sie bleibt erhalten, lässt sich aber
+ * nicht mehr starten, kopieren, exportieren oder teilen. Der Spieler kann sie
+ * aus einer sauberen Sicherung als neue Instanz wiederherstellen und muss die
+ * gesperrte selbst löschen.
+ *
+ * Ehrlich gesagt: Ein Schadprogramm, das gezielt AeroMC angreift und unter
+ * demselben Windows-Konto läuft, kann auch den DPAPI-Schlüssel benutzen. Gegen
+ * allgemeine Jar-Infektionen, fremde Tools und Hände am Dateisystem hilft es.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const ENC = 'enc:v1:';
+const MOD_ENDUNGEN = /\.(jar|zip|litemod)(\.disabled)?$/i;
+
+let datenOrdner = null;
+let store = null;
+let schluessel = null;
+let zustand = { version: 1, instanzen: {} };
+// Pfad -> { groesse, zeit, hash }: nur für die schnelle Prüfung beim Launcher-Start
+let hashCache = new Map();
+
+function zustandsDatei() { return path.join(datenOrdner, 'integritaet.json'); }
+function schluesselDatei() { return path.join(datenOrdner, 'integritaet.key'); }
+
+function init(userData, tresor, storeModul) {
+  datenOrdner = userData;
+  store = storeModul;
+  schluessel = ladeSchluessel(tresor);
+  if (!schluessel) return;
+  let roh = null;
+  try { roh = JSON.parse(fs.readFileSync(zustandsDatei(), 'utf8')); } catch { /* erster Start oder Datei fehlt */ }
+  zustand = { version: 1, instanzen: (roh && roh.instanzen && typeof roh.instanzen === 'object') ? roh.instanzen : {} };
+  // Siegel und Sperre sind getrennt unterschrieben: Wer nur die Sperre aus der
+  // Datei löscht, bekommt sie zurück – der gute Stand (für die Prüfung der
+  // Sicherungen) bleibt dabei gültig. Wer am Siegel selbst dreht, verliert ihn.
+  const jetzt = () => new Date().toISOString();
+  for (const [id, e] of Object.entries(zustand.instanzen)) {
+    if (!e || e.mac !== siegelMac(id, e)) {
+      zustand.instanzen[id] = versiegeltEintrag(id, {
+        felder: {}, dateien: {},
+        gesperrt: { seit: jetzt(), gruende: ['Das Siegel dieser Instanz wurde verändert.'] },
+      });
+    } else if (e.sperrMac !== sperrMac(id, e.gesperrt)) {
+      zustand.instanzen[id] = versiegeltEintrag(id, {
+        felder: e.felder, dateien: e.dateien,
+        gesperrt: (e.gesperrt && e.gesperrt.seit) ? e.gesperrt
+          : { seit: jetzt(), gruende: ['Die Sperre dieser Instanz wurde von Hand aufgehoben.'] },
+      });
+    }
+  }
+  // Liste aller versiegelten Instanzen: ein gelöschter Eintrag fällt auf
+  if (roh && Array.isArray(roh.ids) && roh.idsMac === listenMac(roh.ids)) {
+    for (const id of roh.ids) {
+      if (!zustand.instanzen[id]) {
+        zustand.instanzen[id] = versiegeltEintrag(id, {
+          felder: {}, dateien: {},
+          gesperrt: { seit: jetzt(), gruende: ['Das Siegel dieser Instanz wurde entfernt.'] },
+        });
+      }
+    }
+  }
+  speichere();
+}
+
+function ladeSchluessel(tresor) {
+  const verfuegbar = (() => { try { return !!(tresor && tresor.available()); } catch { return false; } })();
+  if (fs.existsSync(schluesselDatei())) {
+    try {
+      const inhalt = fs.readFileSync(schluesselDatei(), 'utf8').trim();
+      const roh = inhalt.startsWith(ENC) ? tresor.decrypt(inhalt.slice(ENC.length)) : inhalt;
+      const s = Buffer.from(roh, 'hex');
+      if (s.length === 32) return s;
+      throw new Error('falsche Länge');
+    } catch (err) {
+      // Vorhanden, aber nicht lesbar (z. B. Datenordner von einem anderen PC
+      // kopiert). Nicht einfach neu anlegen – dann sähen ALLE Siegel verändert
+      // aus und jede Instanz wäre gesperrt. Schutz bleibt dann aus.
+      console.warn('Integritäts-Schlüssel nicht lesbar – Manipulationsschutz inaktiv:', err.message);
+      return null;
+    }
+  }
+  const neu = crypto.randomBytes(32);
+  const text = verfuegbar ? ENC + tresor.encrypt(neu.toString('hex')) : neu.toString('hex');
+  fs.mkdirSync(datenOrdner, { recursive: true });
+  fs.writeFileSync(schluesselDatei(), text);
+  return neu;
+}
+
+function speichere() {
+  const tmp = zustandsDatei() + '.tmp';
+  const ids = Object.keys(zustand.instanzen).sort();
+  fs.writeFileSync(tmp, JSON.stringify(Object.assign({}, zustand, { ids, idsMac: listenMac(ids) }), null, 1));
+  fs.renameSync(tmp, zustandsDatei());
+}
+
+function sortiert(obj) {
+  return Object.keys(obj || {}).sort().map((k) => [k, obj[k]]);
+}
+
+function hmac(daten) {
+  return crypto.createHmac('sha256', schluessel).update(JSON.stringify(daten)).digest('hex');
+}
+function siegelMac(id, e) { return hmac(['siegel', id, sortiert(e.felder), sortiert(e.dateien)]); }
+function sperrMac(id, gesperrt) { return hmac(['sperre', id, gesperrt || null]); }
+function listenMac(ids) { return hmac(['liste', ids]); }
+
+function versiegeltEintrag(id, e) {
+  const eintrag = { felder: e.felder, dateien: e.dateien, gesperrt: e.gesperrt || null, stand: new Date().toISOString() };
+  eintrag.mac = siegelMac(id, eintrag);
+  eintrag.sperrMac = sperrMac(id, eintrag.gesperrt);
+  return eintrag;
+}
+
+// Die sicherheitsrelevanten Startdaten einer Instanz
+function startDaten(inst) {
+  const j = (inst && inst.java) || {};
+  return {
+    javaPfad: String(j.path || ''),
+    jvmArgumente: String(j.extraArgs || ''),
+    vorStart: String((inst && inst.preLaunchCommand) || ''),
+    nachEnde: String((inst && inst.postExitCommand) || ''),
+  };
+}
+
+const FELD_NAMEN = {
+  javaPfad: 'Java-Pfad', jvmArgumente: 'JVM-Argumente', vorStart: 'Befehl vor dem Start', nachEnde: 'Befehl nach dem Beenden',
+};
+
+// Alle Mod-Dateien (auch Unterordner wie mods/1.12.2/). Schlüssel ohne
+// ".disabled" und in Kleinbuchstaben – Umschalten ist keine Veränderung.
+function modDateien(gameDir) {
+  const basis = path.join(gameDir, 'mods');
+  const ergebnis = {};
+  const lauf = (ordner, tiefe) => {
+    let eintraege;
+    try { eintraege = fs.readdirSync(ordner, { withFileTypes: true }); } catch { return; }
+    for (const e of eintraege) {
+      const voll = path.join(ordner, e.name);
+      if (e.isDirectory()) { if (tiefe < 2) lauf(voll, tiefe + 1); continue; }
+      if (!e.isFile() || !MOD_ENDUNGEN.test(e.name)) continue;
+      const rel = path.relative(basis, voll).replace(/\\/g, '/');
+      ergebnis[rel.replace(/\.disabled$/i, '').toLowerCase()] = voll;
+    }
+  };
+  lauf(basis, 0);
+  return ergebnis;
+}
+
+function hashDatei(datei) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash('sha256');
+    fs.createReadStream(datei).on('error', reject).on('data', (d) => h.update(d)).on('end', () => resolve(h.digest('hex')));
+  });
+}
+
+// schnell=true: unveränderte Größe+Zeit -> Hash aus dem Zwischenspeicher
+async function hashe(datei, schnell) {
+  const st = fs.statSync(datei);
+  const c = hashCache.get(datei);
+  if (schnell && c && c.groesse === st.size && c.zeit === st.mtimeMs) return c.hash;
+  const hash = await hashDatei(datei);
+  hashCache.set(datei, { groesse: st.size, zeit: st.mtimeMs, hash });
+  return hash;
+}
+
+async function aktuellerStand(id, schnell) {
+  const inst = store.getInstance(id);
+  if (!inst) return null;
+  const dateien = {};
+  for (const [schl, voll] of Object.entries(modDateien(store.gameDir(id)))) {
+    try { dateien[schl] = await hashe(voll, schnell); } catch { /* gesperrt/weg -> beim nächsten Mal */ }
+  }
+  return { felder: startDaten(inst), dateien };
+}
+
+function status(id) {
+  const e = zustand.instanzen[id];
+  return e && e.gesperrt ? { gesperrt: true, seit: e.gesperrt.seit, gruende: e.gesperrt.gruende } : { gesperrt: false };
+}
+
+function istGesperrt(id) { return status(id).gesperrt; }
+
+function sperre(id, gruende) {
+  if (!schluessel) return;
+  const e = zustand.instanzen[id] || { felder: {}, dateien: {} };
+  // das letzte gute Siegel bleibt stehen – daran wird eine Sicherung gemessen
+  zustand.instanzen[id] = versiegeltEintrag(id, {
+    felder: e.felder, dateien: e.dateien,
+    gesperrt: { seit: new Date().toISOString(), gruende },
+  });
+  speichere();
+}
+
+/*
+ * Prüft eine Instanz gegen ihr Siegel.
+ * -> { status: 'ok' | 'neu' | 'gesperrt', gruende?, neuGesperrt? }
+ * Ohne Befund werden neue und entfernte Mods ins Siegel übernommen.
+ */
+async function pruefe(id, { schnell = false } = {}) {
+  if (!schluessel) return { status: 'ok' };
+  const vorhanden = zustand.instanzen[id];
+  if (vorhanden && vorhanden.gesperrt) return { status: 'gesperrt', gruende: vorhanden.gesperrt.gruende };
+  const jetzt = await aktuellerStand(id, schnell);
+  if (!jetzt) return { status: 'ok' };
+  if (!vorhanden) {
+    zustand.instanzen[id] = versiegeltEintrag(id, jetzt);
+    speichere();
+    return { status: 'neu' };
+  }
+  const gruende = [];
+  for (const [k, name] of Object.entries(FELD_NAMEN)) {
+    if ((vorhanden.felder[k] || '') !== jetzt.felder[k]) gruende.push(`${name} wurde außerhalb des Launchers geändert.`);
+  }
+  for (const [datei, hash] of Object.entries(jetzt.dateien)) {
+    if (vorhanden.dateien[datei] && vorhanden.dateien[datei] !== hash) gruende.push(`Mod-Datei verändert: ${datei}`);
+  }
+  if (gruende.length) {
+    sperre(id, gruende);
+    return { status: 'gesperrt', gruende, neuGesperrt: true };
+  }
+  const geaendert = JSON.stringify(sortiert(vorhanden.dateien)) !== JSON.stringify(sortiert(jetzt.dateien));
+  if (geaendert) {
+    zustand.instanzen[id] = versiegeltEintrag(id, jetzt);
+    speichere();
+  }
+  return { status: 'ok' };
+}
+
+// Nach einer Änderung durch den Launcher selbst (Mod-Update, Bearbeiten …)
+async function versiegele(id) {
+  if (!schluessel) return;
+  if (istGesperrt(id)) return;
+  const jetzt = await aktuellerStand(id, false);
+  if (!jetzt) return;
+  zustand.instanzen[id] = versiegeltEintrag(id, jetzt);
+  speichere();
+}
+
+function entferne(id) {
+  if (!schluessel) return;
+  if (!zustand.instanzen[id]) return;
+  delete zustand.instanzen[id];
+  speichere();
+}
+
+function alleGesperrten() {
+  const r = {};
+  for (const [id, e] of Object.entries(zustand.instanzen)) if (e.gesperrt) r[id] = { seit: e.gesperrt.seit, gruende: e.gesperrt.gruende };
+  return r;
+}
+
+// Das letzte gute Siegel (für die Prüfung einer Sicherung)
+function gutesSiegel(id) {
+  const e = zustand.instanzen[id];
+  return e ? { felder: e.felder, dateien: e.dateien } : null;
+}
+
+// ---------------------------------------------------------------------------
+// Wiederherstellen aus einer Sicherung (AeroMC-Backup-*.zip, siehe backup.js)
+// ---------------------------------------------------------------------------
+
+const unterPfad = (p) => String(p || '').replace(/\\/g, '/');
+
+/*
+ * Neueste Sicherung, in der die Instanz steckt UND deren Mods zum letzten
+ * guten Siegel passen. Eine Sicherung, die erst nach der Manipulation entstand,
+ * enthält die veränderte Datei und wird übersprungen.
+ * backupPfade: neueste zuerst
+ */
+async function sucheSaubereSicherung(id, backupPfade) {
+  const unzipper = require('unzipper');
+  const gut = gutesSiegel(id);
+  const praefix = `instances/${id}/`;
+  const uebersprungen = [];
+  for (const zip of backupPfade) {
+    let verzeichnis;
+    try { verzeichnis = await unzipper.Open.file(zip); } catch { continue; }
+    const eintraege = verzeichnis.files.filter((f) => f.type === 'File' && unterPfad(f.path).startsWith(praefix));
+    if (!eintraege.some((f) => unterPfad(f.path) === praefix + 'instance.json')) continue;
+    let sauber = true;
+    for (const f of eintraege) {
+      const m = unterPfad(f.path).slice(praefix.length).match(/^minecraft\/mods\/(.+)$/i);
+      if (!m || !MOD_ENDUNGEN.test(m[1])) continue;
+      const schl = m[1].replace(/\.disabled$/i, '').toLowerCase();
+      if (!gut || !gut.dateien[schl]) continue;
+      const hash = crypto.createHash('sha256').update(await f.buffer()).digest('hex');
+      if (hash !== gut.dateien[schl]) { sauber = false; break; }
+    }
+    if (sauber) return { zip, eintraege, praefix, uebersprungen };
+    uebersprungen.push(path.basename(zip));
+  }
+  return { zip: null, uebersprungen };
+}
+
+/*
+ * Stellt die Instanz als NEUE Instanz "<Name> (wiederhergestellt)" wieder her.
+ * Die gesperrte bleibt unangetastet liegen.
+ */
+async function stelleWiederHer(id, backupPfade) {
+  const { pipeline } = require('stream/promises');
+  const fund = await sucheSaubereSicherung(id, backupPfade);
+  if (!fund.zip) {
+    throw new Error(fund.uebersprungen.length
+      ? `Keine saubere Sicherung gefunden – ${fund.uebersprungen.length} Sicherung(en) enthalten bereits die veränderten Dateien.`
+      : 'Keine Sicherung mit dieser Instanz gefunden. Sicherungen lassen sich unter Optionen → Sicherung anlegen.');
+  }
+  const alt = store.getInstance(id);
+  const name = `${(alt && alt.name) || id} (wiederhergestellt)`;
+  const neuId = store.uniqueFolderId(name);
+  const ziel = store.instancePath(neuId);
+  fs.mkdirSync(ziel, { recursive: true });
+  for (const f of fund.eintraege) {
+    const rel = unterPfad(f.path).slice(fund.praefix.length);
+    const dest = path.join(ziel, ...rel.split('/'));
+    if (!dest.startsWith(ziel + path.sep)) continue;   // nichts außerhalb des Ordners
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    await pipeline(f.stream(), fs.createWriteStream(dest));
+  }
+  const datei = path.join(ziel, 'instance.json');
+  const inst = JSON.parse(fs.readFileSync(datei, 'utf8'));
+  inst.id = neuId;
+  inst.name = name;
+  // Startdaten auf den letzten geprüften Stand setzen
+  const gut = gutesSiegel(id);
+  if (gut && gut.felder && Object.keys(gut.felder).length) {
+    inst.java = Object.assign({}, inst.java, { path: gut.felder.javaPfad || '', extraArgs: gut.felder.jvmArgumente || '' });
+    inst.preLaunchCommand = gut.felder.vorStart || '';
+    inst.postExitCommand = gut.felder.nachEnde || '';
+  }
+  fs.writeFileSync(datei, JSON.stringify(inst, null, 2));
+  await versiegele(neuId);
+  return { id: neuId, name, sicherung: path.basename(fund.zip), uebersprungen: fund.uebersprungen };
+}
+
+module.exports = {
+  init, pruefe, versiegele, sperre, status, istGesperrt, entferne, alleGesperrten, gutesSiegel,
+  sucheSaubereSicherung, stelleWiederHer,
+  startDaten, modDateien, hashDatei, FELD_NAMEN,
+};

src/javadl.js

@@ -13,6 +13,14 @@
 const fs = require('fs');
 const path = require('path');
 const unzipper = require('unzipper');
+const crypto = require('crypto');
+
+function sha256Datei(datei) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash('sha256');
+    fs.createReadStream(datei).on('error', reject).on('data', (d) => h.update(d)).on('end', () => resolve(h.digest('hex')));
+  });
+}
 
 const API = 'https://api.adoptium.net/v3';
 const UA = 'AeroMC-Launcher';
@@ -193,6 +201,11 @@ async function ensureJava(major, onProgress) {
   try {
     if (onProgress) onProgress({ phase: 'java-download', geladen: 0, gesamt: release.size, percent: 0 });
     await ladeDatei(release.url, tmpZip, onProgress);
+    // Adoptium nennt zu jedem Paket die SHA-256 – ohne passende Prüfsumme wird
+    // keine Java-Laufzeit entpackt (sie würde später jedes Spiel ausführen)
+    const soll = String(release.sha256 || '').toLowerCase();
+    if (!/^[0-9a-f]{64}$/.test(soll)) throw new Error('Adoptium hat keine Prüfsumme für dieses Java-Paket geliefert – Download verworfen.');
+    if (await sha256Datei(tmpZip) !== soll) throw new Error('Prüfsumme des Java-Downloads stimmt nicht – Datei verworfen (beschädigt oder manipuliert).');
     // in einen Nebenordner entpacken und erst am Ende umbenennen -> kein
     // halbfertiges Java, falls unterwegs etwas schiefgeht
     const tmpDir = ziel + '.teil';

src/kopieren.js

@@ -0,0 +1,182 @@
+/*
+ * Große Ordner kopieren, ohne den Launcher einzufrieren.
+ *
+ * Früher liefen Importe mit fs.cpSync – synchron im Hauptprozess. Bei
+ * Spielständen mit vielen Gigabyte stand dann der komplette Launcher
+ * minutenlang still (keine Anzeige, kein Abbrechen, „Keine Rückmeldung“).
+ *
+ * Hier wird asynchron gearbeitet: erst Dateien und Größe zählen, dann mit
+ * mehreren Dateien gleichzeitig kopieren. Große Dateien gehen stückweise, damit
+ * der Fortschritt auch bei einer einzelnen 4-GB-Datei weiterläuft. Gesperrte
+ * Einzeldateien werden übersprungen und gemeldet statt alles abzubrechen.
+ */
+const fs = require('fs');
+const fsp = fs.promises;
+const path = require('path');
+const { pipeline } = require('stream/promises');
+
+const GLEICHZEITIG = 8;                    // Dateien parallel
+const STUECKWEISE_AB = 64 * 1024 * 1024;   // ab hier mit Zwischenständen kopieren
+const MAX_TIEFE = 64;                      // Schutz vor Verknüpfungs-Schleifen
+const MELDE_ALLE_MS = 200;
+
+class Abgebrochen extends Error {
+  constructor() { super('Vom Nutzer abgebrochen.'); this.abgebrochen = true; }
+}
+
+// Ordner-/Dateieintrag auflösen (Verknüpfungen werden wie ihr Ziel behandelt –
+// die Modrinth App verlinkt z. B. Dateien aus ihrem gemeinsamen Speicher)
+async function art(voll, eintrag) {
+  if (!eintrag.isSymbolicLink()) return { ordner: eintrag.isDirectory(), datei: eintrag.isFile() };
+  const st = await fsp.stat(voll).catch(() => null);
+  return st ? { ordner: st.isDirectory(), datei: st.isFile() } : { ordner: false, datei: false };
+}
+
+/** Zählt Dateien und Bytes unter allen Quellen (Dateien oder Ordner). */
+async function zaehle(quellen, job, melde) {
+  const summe = { dateien: 0, bytes: 0 };
+  let zuletzt = 0;
+  async function lauf(voll, tiefe) {
+    if (job && job.abgebrochen) throw new Abgebrochen();
+    const st = await fsp.stat(voll).catch(() => null);
+    if (!st) return;
+    if (st.isFile()) { summe.dateien++; summe.bytes += st.size; }
+    else if (st.isDirectory() && tiefe < MAX_TIEFE) {
+      const eintraege = await fsp.readdir(voll, { withFileTypes: true }).catch(() => []);
+      for (const e of eintraege) {
+        const p = path.join(voll, e.name);
+        const a = await art(p, e);
+        if (a.ordner) await lauf(p, tiefe + 1);
+        else if (a.datei) {
+          const s = await fsp.stat(p).catch(() => null);
+          if (s) { summe.dateien++; summe.bytes += s.size; }
+        }
+      }
+    }
+    if (melde && Date.now() - zuletzt > MELDE_ALLE_MS) { zuletzt = Date.now(); melde({ ...summe }); }
+  }
+  for (const q of quellen) await lauf(q, 0);
+  if (melde) melde({ ...summe });
+  return summe;
+}
+
+/** Freier Platz (Bytes) auf dem Laufwerk von `ordner`, null wenn unbekannt. */
+async function freierPlatz(ordner) {
+  try {
+    let pruefe = ordner;
+    while (!fs.existsSync(pruefe) && path.dirname(pruefe) !== pruefe) pruefe = path.dirname(pruefe);
+    const s = await fsp.statfs(pruefe);
+    return s.bavail * s.bsize;
+  } catch { return null; }
+}
+
+/**
+ * Fortschritt über mehrere Kopiervorgänge hinweg (z. B. alle Instanzen eines
+ * Imports). `melde` bekommt höchstens alle 200 ms einen Zwischenstand.
+ */
+function neuerFortschritt(gesamt, melde) {
+  const f = {
+    gesamtBytes: gesamt.bytes || 0, gesamtDateien: gesamt.dateien || 0,
+    bytes: 0, dateien: 0, datei: '', uebersprungen: [],
+    beginn: Date.now(), zuletzt: 0, verlauf: [],
+  };
+  f.melden = (sofort) => {
+    const jetzt = Date.now();
+    if (!melde || (!sofort && jetzt - f.zuletzt < MELDE_ALLE_MS)) return;
+    f.zuletzt = jetzt;
+    // Tempo über die letzten ~5 Sekunden glätten
+    f.verlauf.push([jetzt, f.bytes]);
+    while (f.verlauf.length > 2 && jetzt - f.verlauf[0][0] > 5000) f.verlauf.shift();
+    const [t0, b0] = f.verlauf[0];
+    const tempo = jetzt > t0 ? ((f.bytes - b0) * 1000) / (jetzt - t0) : 0;
+    // erst nach 1,5 s schätzen – davor gibt es noch kein brauchbares Tempo
+    const eingeschwungen = jetzt - f.beginn > 1500;
+    const rest = eingeschwungen && tempo > 0 && f.gesamtBytes > f.bytes ? Math.round((f.gesamtBytes - f.bytes) / tempo) : null;
+    melde({
+      bytes: f.bytes, gesamtBytes: f.gesamtBytes, dateien: f.dateien, gesamtDateien: f.gesamtDateien,
+      datei: f.datei, tempo: eingeschwungen ? Math.round(tempo) : 0, restSekunden: rest, uebersprungen: f.uebersprungen.length,
+    });
+  };
+  return f;
+}
+
+async function kopiereDatei(von, nach, groesse, fortschritt, job) {
+  if (groesse >= STUECKWEISE_AB) {
+    // große Datei: stückweise, damit der Balken weiterläuft
+    const lesen = fs.createReadStream(von, { highWaterMark: 4 * 1024 * 1024 });
+    lesen.on('data', (stueck) => {
+      if (job && job.abgebrochen) { lesen.destroy(new Abgebrochen()); return; }
+      if (fortschritt) { fortschritt.bytes += stueck.length; fortschritt.melden(); }
+    });
+    await pipeline(lesen, fs.createWriteStream(nach));
+  } else {
+    await fsp.copyFile(von, nach);
+    if (fortschritt) fortschritt.bytes += groesse;
+  }
+}
+
+/**
+ * Kopiert `von` (Datei oder Ordner) nach `nach`. Läuft asynchron, meldet über
+ * `fortschritt` (siehe neuerFortschritt) und bricht ab, sobald job.abgebrochen.
+ * Gesperrte Einzeldateien landen in fortschritt.uebersprungen; volle Platte
+ * (ENOSPC) und Abbruch beenden den ganzen Vorgang mit Fehler.
+ */
+async function kopiere(von, nach, fortschritt, job) {
+  const laufend = new Set();
+  let schwererFehler = null;
+
+  async function platz(aufgabe) {
+    while (laufend.size >= GLEICHZEITIG) await Promise.race(laufend);
+    if (schwererFehler) throw schwererFehler;
+    const p = aufgabe().catch((err) => {
+      if (err && (err.abgebrochen || err.code === 'ENOSPC')) schwererFehler = schwererFehler || err;
+      else if (fortschritt) fortschritt.uebersprungen.push({ datei: err && err.path ? err.path : '?', grund: err && err.code ? err.code : String(err && err.message) });
+    }).finally(() => laufend.delete(p));
+    laufend.add(p);
+  }
+
+  const basis = von;
+  async function datei(q, z) {
+    if (job && job.abgebrochen) throw new Abgebrochen();
+    const st = await fsp.stat(q);
+    if (fortschritt) fortschritt.datei = path.relative(path.dirname(basis), q);
+    await kopiereDatei(q, z, st.size, fortschritt, job);
+    if (fortschritt) { fortschritt.dateien++; fortschritt.melden(); }
+  }
+
+  async function ordner(q, z, tiefe) {
+    if (job && job.abgebrochen) throw new Abgebrochen();
+    if (schwererFehler) throw schwererFehler;
+    await fsp.mkdir(z, { recursive: true });
+    if (tiefe >= MAX_TIEFE) return;
+    const eintraege = await fsp.readdir(q, { withFileTypes: true });
+    for (const e of eintraege) {
+      const qq = path.join(q, e.name);
+      const zz = path.join(z, e.name);
+      const a = await art(qq, e);
+      if (a.ordner) await ordner(qq, zz, tiefe + 1);
+      else if (a.datei) await platz(() => datei(qq, zz));
+    }
+  }
+
+  let fehler = null;
+  try {
+    const st = await fsp.stat(von);
+    if (st.isDirectory()) await ordner(von, nach, 0);
+    else {
+      await fsp.mkdir(path.dirname(nach), { recursive: true });
+      await platz(() => datei(von, nach));
+    }
+  } catch (err) {
+    fehler = err;
+  }
+  // erst zurückkehren, wenn keine Datei mehr geschrieben wird – sonst würde
+  // das Aufräumen nach einem Abbruch mit noch laufenden Kopien kollidieren
+  while (laufend.size) await Promise.allSettled([...laufend]);
+  if (fehler) throw fehler;
+  if (schwererFehler) throw schwererFehler;
+  if (job && job.abgebrochen) throw new Abgebrochen();
+  if (fortschritt) fortschritt.melden(true);
+}
+
+module.exports = { zaehle, kopiere, freierPlatz, neuerFortschritt, Abgebrochen };

src/launcher.js

@@ -52,11 +52,20 @@ async function downloadIfNeeded(url, dest, sha1) {
     if (!sha1 || sha1File(dest) === sha1) return { skipped: true, bytes: 0 };
   }
   ensureDir(path.dirname(dest));
+  // Mojang (und die Loader) nennen zu jeder Datei die SHA-1 – geschrieben wird
+  // nur, was dazu passt. Ein Fehlversuch wird einmal wiederholt (abgebrochene
+  // Übertragung), dann gilt die Datei als beschädigt oder manipuliert.
+  for (let versuch = 1; ; versuch++) {
     const res = await fetch(url, { headers: { 'User-Agent': UA } });
     if (!res.ok) throw new Error('Download HTTP ' + res.status + ': ' + url);
     const buf = Buffer.from(await res.arrayBuffer());
+    if (sha1 && crypto.createHash('sha1').update(buf).digest('hex') !== String(sha1).toLowerCase()) {
+      if (versuch < 2) continue;
+      throw new Error('Prüfsumme stimmt nicht – Datei verworfen (beschädigt oder manipuliert): ' + path.basename(dest));
+    }
     fs.writeFileSync(dest, buf);
     return { skipped: false, bytes: buf.length };
+  }
 }
 
 // begrenzte Parallelität für viele kleine Downloads (Assets)
@@ -254,8 +263,7 @@ async function prepareAssets(vj, sharedDir, onProgress) {
 // ---------------------------------------------------------------------------
 
 function pickJava(vj, preferredPath) {
-  const required = (vj.javaVersion && vj.javaVersion.majorVersion) || 8;
+  const required = (vj.javaVersion && vj.javaVersion.majorVersion) || 8;  let preferred = null;
-  let preferred = null;
   if (preferredPath && preferredPath.trim()) {
     const info = services.probeJava(preferredPath);
     if (info) {
@@ -301,10 +309,18 @@ function collectArgs(argList, map) {
 // führt Vanilla-Version + Loader-Profil zusammen (mainClass + Argumente)
 function mergeLoader(vj, lp) {
   const merged = Object.assign({}, vj, { mainClass: lp.mainClass || vj.mainClass });
+  if (vj.arguments || lp.arguments) {
     merged.arguments = {
       jvm: [...((vj.arguments && vj.arguments.jvm) || []), ...((lp.arguments && lp.arguments.jvm) || [])],
       game: [...((vj.arguments && vj.arguments.game) || []), ...((lp.arguments && lp.arguments.game) || [])],
     };
+  } else if (lp.minecraftArguments) {
+    // altes Format (< 1.13, z. B. Forge 1.12.2): Die Loader-Fassung enthält die
+    // kompletten Spielargumente samt --tweakClass. Früher entstand hier eine
+    // leere "arguments"-Liste – dann fehlten Klassenpfad (-cp) und Natives im
+    // Startbefehl, und Java fand net.minecraft.launchwrapper.Launch nicht.
+    merged.minecraftArguments = lp.minecraftArguments;
+  }
   return merged;
 }
 
@@ -344,6 +360,8 @@ function buildArgs(vj, ctx) {
   // RAM
   jvm = ['-Xms' + ctx.minMemMb + 'M', '-Xmx' + ctx.maxMemMb + 'M', ...jvm];
   if (ctx.extraArgs) jvm = [...ctx.extraArgs.split(' ').filter(Boolean), ...jvm];
+  // AeroMC-Umhang-Agent (zeigt eigene Umhänge im Spiel, siehe agent/)
+  if (ctx.javaAgent) jvm = ['-javaagent:' + ctx.javaAgent, ...jvm];
 
   return [...jvm, vj.mainClass, ...game];
 }
@@ -528,6 +546,7 @@ async function prepareAndLaunch(opts, onProgress) {
     minMemMb: opts.minMemMb || 2048,
     maxMemMb: opts.maxMemMb || 4096,
     extraArgs: opts.extraArgs || '',
+    javaAgent: opts.javaAgent || '',
   });
 
   // Fenstergröße bzw. maximiert starten (Minecraft-Argumente)
@@ -535,6 +554,10 @@ async function prepareAndLaunch(opts, onProgress) {
   else if (opts.mcWidth && opts.mcHeight) args.push('--width', String(opts.mcWidth), '--height', String(opts.mcHeight));
   // Direkt einem Server beitreten: ab 1.20 per Quick Play, davor über die
   // älteren Startparameter --server/--port (z. B. für "Beitreten" bei Freunden)
+  // Direkt in eine Einzelspieler-Welt (ab 1.20, z. B. nach einem Neustart über den Mod-Schalter)
+  if (!opts.quickPlayServer && opts.quickPlayWelt && !vorQuickPlay(opts.versionId)) {
+    args.push('--quickPlaySingleplayer', String(opts.quickPlayWelt));
+  }
   if (opts.quickPlayServer) {
     const adresse = String(opts.quickPlayServer).trim();
     if (vorQuickPlay(opts.versionId)) {
@@ -548,6 +571,14 @@ async function prepareAndLaunch(opts, onProgress) {
 
   ensureDir(opts.gameDir);
 
+  // AeroMC-Look im Spiel (Ressourcenpaket, siehe spieldesign.js) – braucht das
+  // fertig geladene Client-JAR, aus dem die Original-Knöpfe umgefärbt werden
+  if (opts.vorStart) {
+    try {
+      await opts.vorStart({ gameDir: opts.gameDir, version: opts.versionId, clientJar }, (line) => emit('log', { line: line + '\n' }));
+    } catch { /* darf den Start nie verhindern */ }
+  }
+
   // Pre-Launch-Befehl (bricht bei Fehler ab)
   if (opts.preLaunchCommand && opts.preLaunchCommand.trim()) {
     emit('log', { line: '[Pre-Launch] ' + opts.preLaunchCommand + '\n' });

src/loaders.js

@@ -54,6 +54,20 @@ function mavenToUrl(base, name) {
 }
 
 // verfügbare Loader-Versionen (für die Anzeige/Auswahl)
+// Versionsnummern zahlenweise vergleichen ("36.2.39" > "36.2.4"), neueste zuerst.
+// Die Maven-Listen von Forge/NeoForge sind nicht verlässlich sortiert – früher
+// landete bei Forge 1.16.5 dadurch die ÄLTESTE Version (36.0.0) vorn.
+function neuesteZuerst(a, b) {
+  const ta = String(a).split(/[.\-+]/), tb = String(b).split(/[.\-+]/);
+  for (let i = 0; i < Math.max(ta.length, tb.length); i++) {
+    const x = ta[i] || '0', y = tb[i] || '0';
+    const nx = /^\d+$/.test(x), ny = /^\d+$/.test(y);
+    if (nx && ny && Number(x) !== Number(y)) return Number(y) - Number(x);
+    if (!(nx && ny) && x !== y) return nx ? -1 : ny ? 1 : y.localeCompare(x); // reine Zahl vor "beta"
+  }
+  return 0;
+}
+
 async function listLoaderVersions(loader, mcVersion) {
   if (loader === 'fabric' || loader === 'quilt') {
     const list = await fetchJson(`${META[loader]}/versions/loader/${mcVersion}`);
@@ -63,14 +77,14 @@ async function listLoaderVersions(loader, mcVersion) {
     const xml = await fetchText(FORGE_META);
     const all = [...xml.matchAll(/<version>([^<]+)<\/version>/g)].map((m) => m[1]);
     const prefix = mcVersion + '-';
-    const versions = all.filter((v) => v.startsWith(prefix)).map((v) => v.slice(prefix.length)).reverse();
+    const versions = all.filter((v) => v.startsWith(prefix)).map((v) => v.slice(prefix.length)).sort(neuesteZuerst);
     return versions.map((v, i) => ({ version: v, stable: i === 0 }));
   }
   if (loader === 'neoforge') {
     const xml = await fetchText(NEOFORGE_META);
     const all = [...xml.matchAll(/<version>([^<]+)<\/version>/g)].map((m) => m[1]);
     const prefix = neoforgePrefix(mcVersion);
-    const versions = all.filter((v) => v.startsWith(prefix)).reverse();
+    const versions = all.filter((v) => v.startsWith(prefix)).sort(neuesteZuerst);
     return versions.map((v, i) => ({ version: v, stable: i === 0 && !/beta/i.test(v) }));
   }
   return [];

src/mcimport.js

@@ -173,16 +173,31 @@ function scan(inputPath) {
   return { ok: true, rootDir, count: list.length, instances: list };
 }
 
+function kopierNamen(sourceDir, usesDefaultGameDir) {
+  return fs.readdirSync(sourceDir).filter((name) => {
+    if (/^launcher_profiles.*\.json$/i.test(name)) return false;
+    if (name === 'versions' || name === 'libraries' || name === 'assets' || name === 'runtime' || name === 'webcache2') return false;
+    return !(usesDefaultGameDir && !shouldCopyRootEntry(name));
+  });
+}
+
 function copyInto(sourceDir, targetDir, usesDefaultGameDir) {
   fs.mkdirSync(targetDir, { recursive: true });
-  for (const name of fs.readdirSync(sourceDir)) {
+  for (const name of kopierNamen(sourceDir, usesDefaultGameDir)) {
-    if (/^launcher_profiles.*\.json$/i.test(name)) continue;
-    if (name === 'versions' || name === 'libraries' || name === 'assets' || name === 'runtime' || name === 'webcache2') continue;
-    if (usesDefaultGameDir && !shouldCopyRootEntry(name)) continue;
     fs.cpSync(path.join(sourceDir, name), path.join(targetDir, name), { recursive: true });
   }
 }
 
+/*
+ * Was beim Übernehmen kopiert wird: [{ von, name }] – `name` ist der Zielname
+ * im Spielordner der neuen Instanz. Das Kopieren selbst erledigt kopieren.js
+ * asynchron mit Fortschritt (main.js → fuehreImportAus).
+ */
+function kopierQuellen(entry) {
+  if (!entry.gameDir || !fs.existsSync(entry.gameDir)) return [];
+  return kopierNamen(entry.gameDir, !!entry.usesDefaultGameDir).map((name) => ({ von: path.join(entry.gameDir, name), name }));
+}
+
 function importOne(store, entry, copyData = true) {
   const created = store.createOrReplaceImportedInstance({
     name: entry.name,
@@ -214,4 +229,4 @@ function importOne(store, entry, copyData = true) {
   return { id: created.id, name: created.name, copied };
 }
 
-module.exports = { scan, importOne, parseLastVersionId, resolveLauncherRoot };
+module.exports = { scan, importOne, kopierQuellen, parseLastVersionId, resolveLauncherRoot };

src/mmcimport.js

@@ -185,4 +185,15 @@ function importOne(store, entry, copyData = true) {
   return { id: created.id, name: created.name, copied };
 }
 
-module.exports = { scan, scanSingle, importOne, resolveInstancesDir, readInstance, findInstanceDir };
+
+/*
+ * Was beim Übernehmen kopiert wird: [{ von, name }] – `name` ist der Zielname
+ * im Spielordner der neuen Instanz. Das Kopieren selbst erledigt kopieren.js
+ * asynchron mit Fortschritt (main.js → fuehreImportAus).
+ */
+function kopierQuellen(entry) {
+  if (!entry.gameDir || !fs.existsSync(entry.gameDir)) return [];
+  return fs.readdirSync(entry.gameDir).map((name) => ({ von: path.join(entry.gameDir, name), name }));
+}
+
+module.exports = { scan, scanSingle, importOne, kopierQuellen, resolveInstancesDir, readInstance, findInstanceDir };

src/moderkennung.js

@@ -0,0 +1,117 @@
+/*
+ * Erkennt Mods, die nicht über AeroMC installiert wurden (von Hand kopiert,
+ * aus MultiMC/CurseForge/Modrinth App übernommen, aus einem Modpack …).
+ *
+ * Solche Dateien haben keine Projekt-Zuordnung, deshalb zeigte der Mod-Katalog
+ * z. B. bei Fabric API „Installieren“, obwohl sie längst im mods-Ordner lag.
+ * Hier wird je Datei die SHA-1-Prüfsumme gebildet und gesammelt bei Modrinth
+ * nachgeschlagen (POST /v2/version_files). Ergebnisse werden zwischengespeichert
+ * (Pfad + Größe + Änderungszeit), damit nicht bei jedem Öffnen neu gerechnet wird.
+ * Ohne Netz bleibt einfach alles wie bisher.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const API = 'https://api.modrinth.com/v2';
+const UA = 'AeroMC-Launcher';
+const NICHT_GEFUNDEN_NEU_PRUEFEN_MS = 7 * 24 * 60 * 60 * 1000;
+
+let cacheDatei = null;
+let cache = null;
+
+function init(userDataDir) {
+  cacheDatei = path.join(userDataDir, 'mod-erkennung.json');
+}
+
+function ladeCache() {
+  if (cache) return cache;
+  try { cache = JSON.parse(fs.readFileSync(cacheDatei, 'utf8')); } catch { cache = {}; }
+  return cache;
+}
+function speichereCache() {
+  try { fs.writeFileSync(cacheDatei, JSON.stringify(cache)); } catch { /* nur Zwischenspeicher */ }
+}
+
+function sha1(datei) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash('sha1');
+    fs.createReadStream(datei).on('data', (d) => h.update(d)).on('error', reject).on('end', () => resolve(h.digest('hex')));
+  });
+}
+
+async function holeJson(url, optionen) {
+  const res = await fetch(url, Object.assign({ headers: { 'User-Agent': UA, 'Content-Type': 'application/json', Accept: 'application/json' } }, optionen));
+  if (!res.ok) throw new Error('Modrinth ' + res.status);
+  return res.json();
+}
+
+/**
+ * Ergänzt Einträge ohne projectId um projectId, Titel und Versionsnummer, sofern
+ * Modrinth die Datei kennt. `dir` ist der Ordner, in dem die Dateien liegen.
+ */
+async function ergaenze(eintraege, dir) {
+  const offen = eintraege.filter((e) => e && !e.projectId && e.filename && !e.fehlt);
+  if (!offen.length || !cacheDatei) return eintraege;
+  const c = ladeCache();
+  const jetzt = Date.now();
+  const zuFragen = new Map(); // sha1 -> [schlüssel]
+  const schluesselVon = new Map();
+
+  for (const e of offen) {
+    const voll = path.join(dir, e.enabled === false ? e.filename + '.disabled' : e.filename);
+    let st;
+    try { st = fs.statSync(voll); } catch { continue; }
+    const schluessel = `${voll}|${st.size}|${Math.round(st.mtimeMs)}`;
+    schluesselVon.set(e, schluessel);
+    const bekannt = c[schluessel];
+    if (bekannt && (bekannt.projectId || jetzt - bekannt.geprueft < NICHT_GEFUNDEN_NEU_PRUEFEN_MS)) continue;
+    try {
+      const hash = (bekannt && bekannt.sha1) || await sha1(voll);
+      c[schluessel] = { sha1: hash, projectId: null, geprueft: 0 };
+      if (!zuFragen.has(hash)) zuFragen.set(hash, []);
+      zuFragen.get(hash).push(schluessel);
+    } catch { /* Datei gerade gesperrt – beim nächsten Mal */ }
+  }
+
+  if (zuFragen.size) {
+    try {
+      const versionen = await holeJson(`${API}/version_files`, {
+        method: 'POST', body: JSON.stringify({ hashes: [...zuFragen.keys()], algorithm: 'sha1' }),
+      });
+      const projektIds = [...new Set(Object.values(versionen).map((v) => v.project_id))];
+      const titel = {};
+      for (let i = 0; i < projektIds.length; i += 100) {
+        const teil = projektIds.slice(i, i + 100);
+        const projekte = await holeJson(`${API}/projects?ids=${encodeURIComponent(JSON.stringify(teil))}`);
+        for (const p of projekte) titel[p.id] = p.title;
+      }
+      for (const [hash, schluessel] of zuFragen) {
+        const v = versionen[hash];
+        for (const s of schluessel) {
+          c[s] = v
+            ? { sha1: hash, projectId: v.project_id, versionId: v.id, versionNumber: v.version_number, title: titel[v.project_id] || null, geprueft: jetzt }
+            : { sha1: hash, projectId: null, geprueft: jetzt };
+        }
+      }
+      speichereCache();
+    } catch {
+      return eintraege.map((e) => anwenden(e, c, schluesselVon));
+    }
+  }
+  return eintraege.map((e) => anwenden(e, c, schluesselVon));
+}
+
+function anwenden(e, c, schluesselVon) {
+  const s = schluesselVon.get(e);
+  const t = s && c[s];
+  if (!t || !t.projectId) return e;
+  return Object.assign({}, e, {
+    projectId: t.projectId,
+    title: t.title || e.title,
+    versionNumber: e.versionNumber === 'Importiert' && t.versionNumber ? t.versionNumber : e.versionNumber,
+    erkannt: true,   // per Prüfsumme bei Modrinth erkannt, nicht über AeroMC installiert
+  });
+}
+
+module.exports = { init, ergaenze };

src/modschalter.js

@@ -0,0 +1,65 @@
+'use strict';
+
+/*
+ * modschalter.js – Mods im laufenden Spiel an- und abschalten
+ * ------------------------------------------------------------
+ * Im Pausemenü wird „Feedback geben“ zu „Mods verwalten“ (siehe
+ * agent/ModsUmbau.java). Ein Klick ruft eine Adresse dieses kleinen, nur lokal
+ * erreichbaren Empfängers auf; der Launcher öffnet daraufhin das Mod-Fenster
+ * über dem Spiel.
+ *
+ * Solange Minecraft läuft, sind die Mod-Dateien gesperrt und geladene Mods
+ * lassen sich ohnehin nicht entladen. Änderungen werden deshalb vorgemerkt
+ * (instance.json -> modsAusstehend) und beim Beenden umgesetzt – das Spiel
+ * läuft weiter, beim nächsten Start gilt der neue Stand.
+ */
+
+const http = require('http');
+const crypto = require('crypto');
+
+let server = null;
+let port = 0;
+const sitzungen = new Map();     // token -> { instanceId, pid }
+let beimKlick = null;            // (sitzung) => void
+
+function starteServer() {
+  if (server) return Promise.resolve(port);
+  return new Promise((resolve, reject) => {
+    server = http.createServer((req, res) => {
+      const m = /^\/mods\/([a-f0-9]{32})$/.exec(req.url || '');
+      const s = m && sitzungen.get(m[1]);
+      if (!s) { res.writeHead(404); res.end(); return; }
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end('ok');
+      if (beimKlick) { try { beimKlick(s); } catch (err) { console.error('Mod-Schalter:', err); } }
+    });
+    server.on('error', (err) => { server = null; reject(err); });
+    server.listen(0, '127.0.0.1', () => { port = server.address().port; resolve(port); });
+  });
+}
+
+/** Neue Sitzung für einen Spielstart -> { token, adresse } (für das Agent-Argument) */
+async function neueSitzung(instanceId) {
+  await starteServer();
+  const token = crypto.randomBytes(16).toString('hex');
+  sitzungen.set(token, { instanceId, pid: null, token });
+  return { token, adresse: `http://127.0.0.1:${port}/mods/${token}` };
+}
+
+function setzePid(token, pid) {
+  const s = sitzungen.get(token);
+  if (s) s.pid = pid;
+}
+
+function beende(token) {
+  sitzungen.delete(token);
+}
+
+function sitzungFuer(instanceId) {
+  for (const s of sitzungen.values()) if (s.instanceId === instanceId && s.pid) return s;
+  return null;
+}
+
+function beiKlick(fn) { beimKlick = fn; }
+
+module.exports = { neueSitzung, setzePid, beende, sitzungFuer, beiKlick };

src/mrimport.js

@@ -395,6 +395,17 @@ async function scan(eingabe) {
 // gehört zur Modrinth App bzw. wird ohnehin neu erzeugt
 const NICHT_KOPIEREN = new Set(['profile.json', 'logs', '.fabric', '.quilt']);
 
+/*
+ * Was beim Übernehmen kopiert wird: [{ von, name }] – `name` ist der Zielname
+ * im Spielordner der neuen Instanz. Das Kopieren selbst erledigt kopieren.js
+ * asynchron mit Fortschritt (main.js → fuehreImportAus).
+ */
+function kopierQuellen(entry) {
+  if (!entry.gameDir || !fs.existsSync(entry.gameDir)) return [];
+  return fs.readdirSync(entry.gameDir).filter((name) => !NICHT_KOPIEREN.has(name.toLowerCase()))
+    .map((name) => ({ von: path.join(entry.gameDir, name), name }));
+}
+
 function copyInto(quelle, ziel) {
   fs.mkdirSync(ziel, { recursive: true });
   for (const name of fs.readdirSync(quelle)) {
@@ -434,4 +445,4 @@ function importOne(store, entry, copyData = true) {
   return { id: created.id, name: created.name, copied };
 }
 
-module.exports = { scan, importOne, standardOrdner };
+module.exports = { scan, importOne, kopierQuellen, standardOrdner };

src/neustart.html

@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+  <meta charset="UTF-8" />
+  <meta http-equiv="Content-Security-Policy" content="default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; img-src 'self'" />
+  <title>AeroMC</title>
+  <!--
+    Neustart-Bildschirm (Mod-Schalter): liegt über dem Minecraft-Fenster, während
+    das Spiel beendet, die Mods umgestellt und Minecraft wieder gestartet wird –
+    bis man wieder auf dem Server bzw. in der Welt ist. Gleiches Bild wie der
+    Ladebildschirm im Spiel; Balken und Text an derselben Stelle (83,25 % der Höhe).
+    Der Launcher steuert die Seite über setze({ text, prozent }) und ausblenden().
+  -->
+  <style>
+    html, body { margin: 0; height: 100%; overflow: hidden; background: #0a0e1a; cursor: default; user-select: none; }
+    #bild { position: fixed; inset: 0; background: #0a0e1a url('assets/spieldesign/neustart.jpg') center / cover no-repeat; }
+    #ganz { position: fixed; inset: 0; opacity: 0; transition: opacity .35s ease; }
+    #ganz.sichtbar { opacity: 1; }
+    #balken {
+      position: absolute; left: 22%; right: 22%; top: 83.25%; height: max(8px, 1.15vh); transform: translateY(-50%);
+      border: max(1px, .18vh) solid #4fd2ff; padding: max(1px, .18vh); box-sizing: content-box; overflow: hidden;
+    }
+    #fuellung { height: 100%; width: 0; background: #4fd2ff; transition: width .4s ease; }
+    #balken.unbestimmt #fuellung { width: 30%; animation: wandern 1.3s ease-in-out infinite; }
+    @keyframes wandern { 0% { transform: translateX(-110%); } 100% { transform: translateX(370%); } }
+    #text {
+      position: absolute; left: 50%; top: 88.5%; transform: translateX(-50%);
+      padding: .55vh 1.6vh .7vh; border-radius: .9vh; background: rgba(6, 12, 28, .7);
+      color: #ecf4ff; font: 600 max(13px, 3.1vh) 'Segoe UI', sans-serif; white-space: nowrap;
+    }
+  </style>
+</head>
+<body>
+  <div id="ganz">
+    <div id="bild"></div>
+    <div id="balken" class="unbestimmt"><div id="fuellung"></div></div>
+    <div id="text">Mods werden übernommen …</div>
+  </div>
+  <script>
+    function setze(stand) {
+      if (stand.text) document.getElementById('text').textContent = stand.text;
+      const balken = document.getElementById('balken');
+      const hatProzent = typeof stand.prozent === 'number';
+      balken.classList.toggle('unbestimmt', !hatProzent);
+      document.getElementById('fuellung').style.width = hatProzent ? Math.max(2, Math.min(100, stand.prozent)) + '%' : '';
+    }
+    function ausblenden() { document.getElementById('ganz').classList.remove('sichtbar'); }
+    requestAnimationFrame(() => document.getElementById('ganz').classList.add('sichtbar'));
+  </script>
+</body>
+</html>

src/preload.js

@@ -5,7 +5,7 @@
  * contextIsolation ist aktiv; der Renderer hat KEINEN direkten Node-Zugriff.
  */
 
-const { contextBridge, ipcRenderer } = require('electron');
+const { contextBridge, ipcRenderer, webUtils } = require('electron');
 
 // Debug-Hilfe: JS-Fehler im Renderer landen im Terminal des Hauptprozesses,
 // damit man sie auch ohne offene DevTools sieht
@@ -16,6 +16,21 @@ window.addEventListener('unhandledrejection', (e) => {
   ipcRenderer.send('debug:rendererError', 'unhandledrejection: ' + ((e.reason && e.reason.stack) || e.reason));
 });
 
+// Zuletzt angeklickter Knopf: Popup-Fenster wachsen daraus hervor
+// (main.js → openPopout). Gilt nur kurz, sonst kämen sie aus einem alten Klick.
+let letzterKlick = null;
+window.addEventListener('pointerdown', (e) => {
+  const t = e.target && e.target.closest ? (e.target.closest('button, a, [role="button"], .card, .snav') || e.target) : null;
+  if (!t || !t.getBoundingClientRect) return;
+  const r = t.getBoundingClientRect();
+  letzterKlick = { x: r.left, y: r.top, width: r.width, height: r.height, zeit: Date.now() };
+}, true);
+function frischerKlick() {
+  if (!letzterKlick || Date.now() - letzterKlick.zeit > 2000) return null;
+  const { x, y, width, height } = letzterKlick;
+  return { x, y, width, height };
+}
+
 contextBridge.exposeInMainWorld('api', {
   // Einstellungen
   getSettings: () => ipcRenderer.invoke('settings:get'),
@@ -104,6 +119,9 @@ contextBridge.exposeInMainWorld('api', {
   openScreenshot: (id, name) => ipcRenderer.invoke('instance:openScreenshot', id, name),
   launchInstance: (id, accountId, opts) => ipcRenderer.invoke('instances:launch', id, accountId, opts),
   exportInstance: (id) => ipcRenderer.invoke('instances:export', id),
+  integritaetWiederherstellen: (id) => ipcRenderer.invoke('integritaet:wiederherstellen', id),
+  // Pfad einer per Drag & Drop abgelegten Datei (File.path gibt es seit Electron 32 nicht mehr)
+  pfadVonDatei: (datei) => { try { return webUtils.getPathForFile(datei) || ''; } catch { return ''; } },
   createGlobalBackup: () => ipcRenderer.invoke('backup:global'),
   listGlobalBackups: () => ipcRenderer.invoke('backup:list'),
   restoreGlobalBackup: (sourcePath) => ipcRenderer.invoke('backup:restore', sourcePath),
@@ -151,6 +169,40 @@ contextBridge.exposeInMainWorld('api', {
   authAccounts: () => ipcRenderer.invoke('auth:accounts'),
   authSetActive: (id) => ipcRenderer.invoke('auth:setActive', id),
   skinProfile: () => ipcRenderer.invoke('skin:profile'),
+  skinArmformPruefen: () => ipcRenderer.invoke('skin:armformPruefen'),
+  garderobeListe: () => ipcRenderer.invoke('garderobe:liste'),
+  erfolgeListe: () => ipcRenderer.invoke('erfolge:liste'),
+  laufendeInstanzen: () => ipcRenderer.invoke('game:laufend'),
+  modschalterDaten: (id) => ipcRenderer.invoke('modschalter:daten', id),
+  modschalterNeustart: (id) => ipcRenderer.invoke('modschalter:neustart', id),
+  modschalterSchliessen: () => ipcRenderer.send('modschalter:schliessen'),
+  onModschalterNeustarten: (cb) => {
+    const l = (_e, d) => cb(d || {});
+    ipcRenderer.on('modschalter:neustarten', l);
+    return () => ipcRenderer.removeListener('modschalter:neustarten', l);
+  },
+  onLaufendeInstanzen: (cb) => {
+    const l = (_e, d) => cb(d || []);
+    ipcRenderer.on('game:laufend', l);
+    return () => ipcRenderer.removeListener('game:laufend', l);
+  },
+  onErfolgeNeu: (cb) => {
+    const l = (_e, d) => cb(d);
+    ipcRenderer.on('erfolge:neu', l);
+    return () => ipcRenderer.removeListener('erfolge:neu', l);
+  },
+  modsLeistungsPaket: (id) => ipcRenderer.invoke('mods:leistungsPaket', id),
+  onPaketFortschritt: (cb) => {
+    const l = (_e, d) => cb(d);
+    ipcRenderer.on('mods:paketFortschritt', l);
+    return () => ipcRenderer.removeListener('mods:paketFortschritt', l);
+  },
+  garderobeSkinSpeichern: (name) => ipcRenderer.invoke('garderobe:skinSpeichern', name),
+  garderobeUmhangSpeichern: (name) => ipcRenderer.invoke('garderobe:umhangSpeichern', name),
+  garderobeAnziehen: (id) => ipcRenderer.invoke('garderobe:anziehen', id),
+  garderobeUmbenennen: (id, name) => ipcRenderer.invoke('garderobe:umbenennen', id, name),
+  garderobeLoeschen: (id) => ipcRenderer.invoke('garderobe:loeschen', id),
+  skinArmformKorrigieren: () => ipcRenderer.invoke('skin:armformKorrigieren'),
   skinChoose: () => ipcRenderer.invoke('skin:choose'),
   skinApply: (pfad, variante) => ipcRenderer.invoke('skin:apply', pfad, variante),
   skinReset: () => ipcRenderer.invoke('skin:reset'),
@@ -159,6 +211,14 @@ contextBridge.exposeInMainWorld('api', {
   skinReadData: (pfad) => ipcRenderer.invoke('skin:readData', pfad),
   skinSaveData: (base64) => ipcRenderer.invoke('skin:saveData', base64),
   skinApplyData: (base64, variante) => ipcRenderer.invoke('skin:applyData', base64, variante),
+  capeInfo: () => ipcRenderer.invoke('cape:info'),
+  capeForUuid: (uuid) => ipcRenderer.invoke('cape:forUuid', uuid),
+  capeSetOfficial: (id) => ipcRenderer.invoke('cape:setOfficial', id),
+  capeUpload: (base64) => ipcRenderer.invoke('cape:upload', base64),
+  capeRemove: () => ipcRenderer.invoke('cape:remove'),
+  capeCurrentData: () => ipcRenderer.invoke('cape:currentData'),
+  capeChooseFile: (art) => ipcRenderer.invoke('cape:chooseFile', art),
+  capeSaveData: (base64) => ipcRenderer.invoke('cape:saveData', base64),
   authRemove: (id) => ipcRenderer.invoke('auth:remove', id),
   authLogin: () => ipcRenderer.invoke('auth:login'),
   authLogout: () => ipcRenderer.invoke('auth:logout'),
@@ -188,6 +248,13 @@ contextBridge.exposeInMainWorld('api', {
 
   // Dialoge / App
   // MultiMC-Import
+  // gemeinsamer Fortschritt aller Launcher-Importe (main.js → fuehreImportAus)
+  onImportFortschritt: (cb) => {
+    const l = (_e, d) => cb(d);
+    ipcRenderer.on('import:fortschritt', l);
+    return () => ipcRenderer.removeListener('import:fortschritt', l);
+  },
+  importAbbrechen: () => ipcRenderer.invoke('import:abbrechen'),
   mmcPickFolder: () => ipcRenderer.invoke('mmc:pickFolder'),
   mmcScan: (folder) => ipcRenderer.invoke('mmc:scan', folder),
   mmcImport: (entries, copyData) => ipcRenderer.invoke('mmc:import', entries, copyData),
@@ -253,7 +320,7 @@ contextBridge.exposeInMainWorld('api', {
   // Updates
   updateCheck: () => ipcRenderer.invoke('update:check'),
   updateLastCheck: () => ipcRenderer.invoke('update:lastCheck'),
-  updateInstall: (asset) => ipcRenderer.invoke('update:install', asset),
+  updateInstall: () => ipcRenderer.invoke('update:install'),
   onUpdateAvailable: (cb) => {
     const l = (_e, d) => cb(d);
     ipcRenderer.on('update:available', l);
@@ -280,7 +347,7 @@ contextBridge.exposeInMainWorld('api', {
   appLicense: () => ipcRenderer.invoke('app:license'),
 
   // Einstellungen/Konsole als eigenes, frei verschiebbares Fenster
-  popoutOpen: (modalId, params) => ipcRenderer.send('popout:open', modalId, params),
+  popoutOpen: (modalId, params) => ipcRenderer.send('popout:open', modalId, params, frischerKlick()),
   popoutHide: () => ipcRenderer.send('popout:hide'),
   setTitleBarDesign: (design) => ipcRenderer.send('window:titleBar', design),
   onPopoutReopen: (cb) => {

src/services.js

@@ -299,6 +299,7 @@ async function modrinthResolveFile({ projectId, gameVersion, loader, art = 'mod'
             versionNumber: v.version_number,
             filename: file.filename,
             url: file.url,
+            hashes: mrHashes(file),
             sha1: file.hashes && file.hashes.sha1,
             size: file.size,
             dependencies: v.dependencies || [],
@@ -324,6 +325,7 @@ async function modrinthResolveFile({ projectId, gameVersion, loader, art = 'mod'
     versionNumber: v.version_number,
     filename: file.filename,
     url: file.url,
+    hashes: mrHashes(file),
     sha1: file.hashes && file.hashes.sha1,
     size: file.size,
     dependencies: v.dependencies || [],
@@ -350,23 +352,58 @@ async function modrinthResolveModpack({ projectId, gameVersion = '' } = {}) {
     name: v.name || v.version_number,
     filename: file.filename,
     url: file.url,
+    hashes: mrHashes(file),
     size: file.size || 0,
     gameVersions: v.game_versions || [],
     loaders: v.loaders || [],
   };
 }
 
-async function downloadBuffer(url, extraHeaders) {
+/*
-  const res = await fetch(url, { headers: Object.assign({ 'User-Agent': UA }, extraHeaders || {}) });
+ * Prüfsumme eines Downloads kontrollieren. erwartet: { sha512?, sha1? } – die
-  if (!res.ok) throw new Error('Download fehlgeschlagen: HTTP ' + res.status);
+ * Werte stammen aus der Modrinth- bzw. CurseForge-API. Ohne Angabe wird nichts
-  return Buffer.from(await res.arrayBuffer());
+ * geprüft (z. B. Dateien, zu denen die Quelle keine Prüfsumme nennt).
+ */
+function pruefeDownload(buf, erwartet, name) {
+  if (!erwartet) return;
+  for (const algo of ['sha512', 'sha256', 'sha1']) {
+    const soll = erwartet[algo] && String(erwartet[algo]).toLowerCase();
+    if (!soll) continue;
+    const ist = require('crypto').createHash(algo).update(buf).digest('hex');
+    if (ist !== soll) {
+      throw new Error(`Prüfsumme von ${name || 'Download'} stimmt nicht – Datei verworfen (beschädigt oder manipuliert).`);
+    }
+    return;
+  }
 }
 
-// extraHeaders: z. B. der CurseForge-API-Key, den das CDN seit Juli 2026 verlangt
+// CurseForge liefert Prüfsummen als Liste: algo 1 = SHA-1, 2 = MD5
-async function downloadFile(url, destPath, extraHeaders) {
+function cfHashes(datei) {
+  const sha1 = ((datei && datei.hashes) || []).find((h) => h.algo === 1 && h.value);
+  return sha1 ? { sha1: sha1.value } : null;
+}
+
+// Modrinth: { sha512, sha1 }
+function mrHashes(datei) {
+  const h = (datei && datei.hashes) || {};
+  return h.sha512 || h.sha1 ? { sha512: h.sha512, sha1: h.sha1 } : null;
+}
+
+async function downloadBuffer(url, extraHeaders, erwartet) {
   const res = await fetch(url, { headers: Object.assign({ 'User-Agent': UA }, extraHeaders || {}) });
   if (!res.ok) throw new Error('Download fehlgeschlagen: HTTP ' + res.status);
   const buf = Buffer.from(await res.arrayBuffer());
+  pruefeDownload(buf, erwartet, decodeURIComponent(String(url).split('/').pop() || ''));
+  return buf;
+}
+
+// extraHeaders: z. B. der CurseForge-API-Key, den das CDN seit Juli 2026 verlangt
+// erwartet: Prüfsummen (siehe pruefeDownload) – geschrieben wird nur, was passt
+async function downloadFile(url, destPath, extraHeaders, erwartet) {
+  const res = await fetch(url, { headers: Object.assign({ 'User-Agent': UA }, extraHeaders || {}) });
+  if (!res.ok) throw new Error('Download fehlgeschlagen: HTTP ' + res.status);
+  const buf = Buffer.from(await res.arrayBuffer());
+  pruefeDownload(buf, erwartet, path.basename(destPath));
   fs.mkdirSync(path.dirname(destPath), { recursive: true });
   fs.writeFileSync(destPath, buf);
   return buf.length;
@@ -383,7 +420,7 @@ async function modrinthInstall({ projectId, title, gameVersion, loader, modsDir,
         : `Keine passende Version für ${gameVersion} gefunden.` };
   }
   const dest = path.join(modsDir, file.filename);
-  const bytes = await downloadFile(file.url, dest);
+  const bytes = await downloadFile(file.url, dest, null, file.hashes);
   return {
     ok: true,
     dependencies: file.dependencies || [],
@@ -738,6 +775,7 @@ async function curseforgePickFile(zugang, modId, gameVersion, loader, art) {
     fileId: match.id,
     filename: name,
     url: dl,
+    hashes: cfHashes(match),
     versionNumber: match.displayName || match.fileName || String(match.id),
     dependencies: match.dependencies || [],
   };
@@ -768,7 +806,7 @@ async function curseforgeInstall({ zugang, projectId, title, gameVersion, loader
   // Download: direkt mit Key oder über Weiterleitung
   const url = zugang.downloadAdresse ? zugang.downloadAdresse(file.url) : file.url;
   const headers = Object.assign({}, zugang.downloadKopfzeilen || {});
-  const bytes = await downloadFile(url, dest, headers);
+  const bytes = await downloadFile(url, dest, headers, file.hashes);
 
   // Pflicht-Abhängigkeiten (relationType 3 = RequiredDependency)
   const depIds = (file.dependencies || [])
@@ -826,6 +864,7 @@ async function curseforgeResolveFiles(zugang, files, onProgress) {
       map.set(Number(d.id), {
         fileName: d.fileName,
         url: zugang.downloadAdresse(roh),
+        hashes: cfHashes(d),
         kopfzeilen: zugang.downloadKopfzeilen,
       });
     }

src/skins.js

@@ -115,7 +115,93 @@ async function holeProfil(accessToken) {
     id: daten.id,
     skinUrl: aktiv ? aufHttps(aktiv.url) : '',
     variante: aktiv ? String(aktiv.variant || '').toLowerCase() : '',
+    // offizielle Umhänge, die dieses Konto besitzt (Migrator, MINECON …)
+    capes: (daten.capes || []).map((c) => ({
+      id: c.id,
+      name: c.alias || 'Umhang',
+      url: aufHttps(c.url),
+      aktiv: c.state === 'ACTIVE',
+    })),
   };
 }
 
-module.exports = { setzeSkin, setzeSkinZurueck, holeProfil, pruefeDatei, aufHttps };
+/*
+ * Offiziellen Umhang wählen (nur einer, den das Konto besitzt) bzw. mit
+ * capeId = null keinen tragen. Gilt im Spiel für alle Spieler.
+ */
+async function setzeUmhang(accessToken, capeId) {
+  const res = await fetch(API + '/minecraft/profile/capes/active', capeId
+    ? {
+      method: 'PUT',
+      headers: { Authorization: 'Bearer ' + accessToken, 'User-Agent': UA, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ capeId }),
+    }
+    : { method: 'DELETE', headers: { Authorization: 'Bearer ' + accessToken, 'User-Agent': UA } });
+  if (!res.ok) return { ok: false, message: fehlerText(res.status) };
+  return { ok: true };
+}
+
+/*
+ * Texturen, die andere Spieler im Spiel sehen (öffentliches Profil beim
+ * Sitzungsserver). Das kann vom Kontoprofil oben abweichen: Dort liefert
+ * Mojang bei manchen Konten einen Standard-Skin (z. B. Efe) als "ACTIVE",
+ * obwohl im Spiel längst ein eigener Skin getragen wird.
+ */
+async function holeSpielTexturen(uuid) {
+  const id = String(uuid || '').replace(/-/g, '').toLowerCase();
+  if (!/^[0-9a-f]{32}$/.test(id)) return null;
+  const res = await fetch('https://sessionserver.mojang.com/session/minecraft/profile/' + id, {
+    headers: { 'User-Agent': UA, Accept: 'application/json' },
+  });
+  if (!res.ok) return null;
+  const profil = await res.json();
+  const eigenschaft = (profil.properties || []).find((p) => p.name === 'textures');
+  if (!eigenschaft) return null;
+  const texturen = JSON.parse(Buffer.from(eigenschaft.value, 'base64').toString('utf8')).textures || {};
+  const skin = texturen.SKIN;
+  return {
+    skinUrl: skin && skin.url ? aufHttps(skin.url) : '',
+    variante: skin && skin.metadata && skin.metadata.model === 'slim' ? 'slim' : 'classic',
+  };
+}
+
+/*
+ * Welcher Skin wird als "aktuell" gezeigt? Grundsätzlich der aus dem Spiel –
+ * nur direkt nach einer eigenen Änderung das Kontoprofil, weil der
+ * Sitzungsserver dann noch kurz den alten Stand liefert.
+ */
+function waehleAnzeigeSkin(kontoProfil, spiel, kuerzlichGeaendert) {
+  if (!kontoProfil || !kontoProfil.ok || kuerzlichGeaendert) return kontoProfil;
+  if (!spiel || !spiel.skinUrl || spiel.skinUrl === kontoProfil.skinUrl) return kontoProfil;
+  return Object.assign({}, kontoProfil, { skinUrl: spiel.skinUrl, variante: spiel.variante, skinAusSpiel: true });
+}
+
+/*
+ * Für welche Armform ist eine Skin-Datei gemalt? Breite Arme (Steve) sind 4
+ * Pixel breit, schmale (Alex) 3 – bei schmalen bleiben deshalb je Arm zwei
+ * Pixelspalten der Rückseite leer: rechter Arm x 54–55 / y 20–31, linker Arm
+ * x 46–47 / y 52–63. bitmap: Rohdaten mit 4 Byte je Pixel (Alpha an Stelle 3).
+ * -> 'classic' | 'slim' | null (nicht eindeutig, alte 64×32-Skins: classic)
+ */
+function armformDerTextur(bitmap, breite, hoehe) {
+  if (!bitmap || !breite || breite % 64 !== 0 || hoehe % 32 !== 0) return null;
+  const f = breite / 64;                       // HD-Skins (128×128 …) mitskalieren
+  if (Math.round(hoehe / f) === 32) return 'classic';
+  if (Math.round(hoehe / f) !== 64) return null;
+  let deckend = 0, gesamt = 0;
+  const pruefe = (x0, y0) => {
+    for (let y = y0 * f; y < (y0 + 12) * f; y++) {
+      for (let x = x0 * f; x < (x0 + 2) * f; x++) {
+        gesamt++;
+        if (bitmap[(y * breite + x) * 4 + 3] > 0) deckend++;
+      }
+    }
+  };
+  pruefe(54, 20);
+  pruefe(46, 52);
+  if (deckend >= gesamt * 0.85) return 'classic';
+  if (deckend <= gesamt * 0.1) return 'slim';
+  return null;
+}
+
+module.exports = { setzeSkin, setzeSkinZurueck, holeProfil, pruefeDatei, aufHttps, setzeUmhang, holeSpielTexturen, waehleAnzeigeSkin, armformDerTextur };

src/spieldesign.js

@@ -0,0 +1,359 @@
+'use strict';
+
+/*
+ * spieldesign.js – AeroMC-Look im Spiel (Minecraft 1.14 … 26.x)
+ * --------------------------------------------------------------
+ * Zwei Teile:
+ *
+ *  1. Ressourcenpaket "AeroMC-Design" im Ordner resourcepacks der Instanz:
+ *     Titel-Logo mit Untertitel, Menü-Hintergrund (Panorama), eigene Sprüche,
+ *     Knöpfe im AeroMC-Stil und Symbole vor den Menü-Beschriftungen (als eigene
+ *     Bitmap-Schrift über die Sprachdateien). Bis 1.20.1 stecken die Knöpfe im
+ *     gemeinsamen widgets.png der Version, ab 1.20.2 sind es eigene Sprites.
+ *     Das Paket wird in options.txt ganz unten eingereiht – eigene
+ *     Ressourcenpakete des Spielers haben also immer Vorrang.
+ *  2. Grafiken für den Agenten (Ladebildschirm-Logo, Fenstersymbol): Java kann
+ *     nicht aus app.asar lesen, darum werden sie nach userData kopiert.
+ *
+ * Für den Mod-Schalter (siehe modschalter.js) bringt das Paket außerdem die
+ * Beschriftung „Mods verwalten“ mit – auch wenn der AeroMC-Look aus ist.
+ * Ist beides aus, wird das Paket wieder entfernt.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+const unzipper = require('unzipper');
+
+const PAKET = 'AeroMC-Design';
+const PAKET_ID = 'file/' + PAKET;
+const STAND = 8;                       // erhöhen, wenn sich die Grafiken ändern -> Paket wird neu gebaut
+const ASSETS = path.join(__dirname, 'assets', 'spieldesign');
+
+// ---------- Versionen ----------
+
+// "1.21.9-rc1" -> [1, 21, 9]; Snapshots wie "25w31a" -> null
+function zahlen(version) {
+  const m = /^(\d+)\.(\d+)(?:\.(\d+))?/.exec(String(version || ''));
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3] || 0)] : null;
+}
+function ab(version, grenze) {
+  const a = zahlen(version);
+  if (!a) return true;                 // Snapshots u. Ä. gelten als neu
+  const b = zahlen(grenze);
+  for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i];
+  return true;
+}
+
+// Ressourcenpaket-Format je Version (minecraft.wiki, "Pack format")
+const FORMATE = [
+  ['1.14', 4], ['1.15', 5], ['1.16.2', 6], ['1.17', 7], ['1.18', 8], ['1.19', 9], ['1.19.3', 12], ['1.19.4', 13],
+  ['1.20', 15], ['1.20.2', 18], ['1.20.3', 22], ['1.20.5', 32], ['1.21', 34], ['1.21.2', 42], ['1.21.4', 46],
+  ['1.21.5', 55], ['1.21.6', 63], ['1.21.7', 64], ['1.21.9', 69], ['1.21.11', 75], ['26.1', 84], ['26.2', 88], ['26.3', 97],
+];
+function paketFormat(version) {
+  let f = FORMATE[FORMATE.length - 1][1];
+  if (zahlen(version)) for (const [v, n] of FORMATE) if (ab(version, v)) f = n;
+  return f;
+}
+function mcmeta(version) {
+  const f = paketFormat(version);
+  const neuste = f === FORMATE[FORMATE.length - 1][1];
+  const pack = { description: 'AeroMC – Menü, Logo und Knöpfe' };
+  if (f >= 65) {
+    // ab 1.21.9: min/max statt pack_format; die neuste bekannte Version offen nach oben
+    pack.min_format = f;
+    pack.max_format = neuste ? 999 : f;
+  } else {
+    pack.pack_format = f;
+  }
+  return JSON.stringify({ pack }, null, 2);
+}
+
+/** Spieldesign gibt es ab 1.14 (vorher andere Menüs und LWJGL 2). */
+function unterstuetzt(version) {
+  return ab(version, '1.14');
+}
+
+// ---------- PNG (verlustfrei, ohne Zusatzbibliothek) ----------
+
+function pngLesen(buf) {
+  if (buf.readUInt32BE(0) !== 0x89504e47) throw new Error('kein PNG');
+  let pos = 8, w = 0, h = 0, tiefe = 0, typ = 0, palette = null, transparenz = null;
+  const idat = [];
+  while (pos < buf.length) {
+    const laenge = buf.readUInt32BE(pos);
+    const art = buf.toString('ascii', pos + 4, pos + 8);
+    const daten = buf.subarray(pos + 8, pos + 8 + laenge);
+    if (art === 'IHDR') {
+      w = daten.readUInt32BE(0); h = daten.readUInt32BE(4); tiefe = daten[8]; typ = daten[9];
+      if (daten[12] !== 0) throw new Error('Interlacing nicht unterstützt');
+    } else if (art === 'PLTE') palette = daten;
+    else if (art === 'tRNS') transparenz = daten;
+    else if (art === 'IDAT') idat.push(daten);
+    else if (art === 'IEND') break;
+    pos += 12 + laenge;
+  }
+  const kanaele = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 }[typ];
+  if (!kanaele || (tiefe !== 8 && !(typ === 3 && tiefe < 8) && !(typ === 0 && tiefe < 8))) throw new Error(`PNG-Format ${typ}/${tiefe} nicht unterstützt`);
+  const roh = zlib.inflateSync(Buffer.concat(idat));
+  const bpp = Math.max(1, (kanaele * tiefe) >> 3);           // Bytes je Pixel für die Filter
+  const zeile = Math.ceil((w * kanaele * tiefe) / 8);
+  const pixel = Buffer.alloc(zeile * h);
+  for (let y = 0; y < h; y++) {
+    const f = roh[y * (zeile + 1)];
+    const ein = roh.subarray(y * (zeile + 1) + 1, (y + 1) * (zeile + 1));
+    const aus = pixel.subarray(y * zeile, (y + 1) * zeile);
+    const oben = y ? pixel.subarray((y - 1) * zeile, y * zeile) : null;
+    for (let i = 0; i < zeile; i++) {
+      const a = i >= bpp ? aus[i - bpp] : 0, b = oben ? oben[i] : 0, c = oben && i >= bpp ? oben[i - bpp] : 0;
+      let v = ein[i];
+      if (f === 1) v += a;
+      else if (f === 2) v += b;
+      else if (f === 3) v += (a + b) >> 1;
+      else if (f === 4) { const p = a + b - c, pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c); v += pa <= pb && pa <= pc ? a : pb <= pc ? b : c; }
+      aus[i] = v & 255;
+    }
+  }
+  const rgba = Buffer.alloc(w * h * 4);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const o = (y * w + x) * 4;
+      let wert;
+      if (tiefe < 8) {
+        const bit = x * tiefe;
+        wert = (pixel[y * zeile + (bit >> 3)] >> (8 - tiefe - (bit & 7))) & ((1 << tiefe) - 1);
+      } else wert = null;
+      const p = y * zeile + x * kanaele;
+      if (typ === 6) { pixel.copy(rgba, o, p, p + 4); continue; }
+      if (typ === 2) { rgba[o] = pixel[p]; rgba[o + 1] = pixel[p + 1]; rgba[o + 2] = pixel[p + 2]; rgba[o + 3] = 255; continue; }
+      if (typ === 4) { rgba[o] = rgba[o + 1] = rgba[o + 2] = pixel[p]; rgba[o + 3] = pixel[p + 1]; continue; }
+      if (typ === 0) {
+        const g = tiefe < 8 ? Math.round((wert * 255) / ((1 << tiefe) - 1)) : pixel[p];
+        rgba[o] = rgba[o + 1] = rgba[o + 2] = g; rgba[o + 3] = 255; continue;
+      }
+      const index = tiefe < 8 ? wert : pixel[p];          // Palette
+      rgba[o] = palette[index * 3]; rgba[o + 1] = palette[index * 3 + 1]; rgba[o + 2] = palette[index * 3 + 2];
+      rgba[o + 3] = transparenz && index < transparenz.length ? transparenz[index] : 255;
+    }
+  }
+  return { w, h, rgba };
+}
+
+const CRC = (() => {
+  const t = new Int32Array(256);
+  for (let n = 0; n < 256; n++) { let c = n; for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1; t[n] = c; }
+  return t;
+})();
+function crc32(buf) {
+  let c = -1;
+  for (let i = 0; i < buf.length; i++) c = CRC[(c ^ buf[i]) & 255] ^ (c >>> 8);
+  return (c ^ -1) >>> 0;
+}
+function block(art, daten) {
+  const kopf = Buffer.alloc(8);
+  kopf.writeUInt32BE(daten.length, 0);
+  kopf.write(art, 4, 'ascii');
+  const pruef = Buffer.alloc(4);
+  pruef.writeUInt32BE(crc32(Buffer.concat([kopf.subarray(4), daten])), 0);
+  return Buffer.concat([kopf, daten, pruef]);
+}
+function pngSchreiben(w, h, rgba) {
+  const roh = Buffer.alloc((w * 4 + 1) * h);
+  for (let y = 0; y < h; y++) rgba.copy(roh, y * (w * 4 + 1) + 1, y * w * 4, (y + 1) * w * 4);
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(w, 0); ihdr.writeUInt32BE(h, 4); ihdr[8] = 8; ihdr[9] = 6;
+  return Buffer.concat([
+    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+    block('IHDR', ihdr), block('IDAT', zlib.deflateSync(roh, { level: 9 })), block('IEND', Buffer.alloc(0)),
+  ]);
+}
+
+// ---------- Paket bauen ----------
+
+async function ausJar(jar, eintraege) {
+  const verz = await unzipper.Open.file(jar);
+  const aus = {};
+  for (const e of eintraege) {
+    const f = verz.files.find((d) => d.path === e);
+    if (f) aus[e] = await f.buffer();
+  }
+  return aus;
+}
+
+function schreibe(datei, inhalt) {
+  fs.mkdirSync(path.dirname(datei), { recursive: true });
+  fs.writeFileSync(datei, inhalt);
+}
+
+async function bauePaket(gameDir, version, clientJar, protokoll, teile) {
+  const { design, mods } = teile;
+  const ziel = path.join(gameDir, 'resourcepacks', PAKET);
+  const marke = path.join(ziel, 'aeromc.json');
+  const kennung = JSON.stringify({ stand: STAND, version, design: !!design, mods: !!mods });
+  try { if (fs.readFileSync(marke, 'utf8') === kennung) return; } catch { /* noch nicht gebaut */ }
+  fs.rmSync(ziel, { recursive: true, force: true });
+
+  const alt = !ab(version, '1.20');                          // Titel-Logo zweigeteilt bis 1.19.4
+  const gui = path.join(ziel, 'assets', 'minecraft', 'textures', 'gui');
+  const asset = (n) => fs.readFileSync(path.join(ASSETS, n));
+  schreibe(path.join(ziel, 'pack.png'), asset('pack.png'));
+  schreibe(path.join(ziel, 'pack.mcmeta'), mcmeta(version));
+
+  // Symbole (Schriftzeichen) und Beschriftungen – für Menü-Knöpfe und/oder „Mods verwalten“
+  schreibe(path.join(ziel, 'assets', 'aeromc', 'textures', 'font', 'symbole.png'), asset('symbole.png'));
+  // Die Schriftdatei ersetzt die von Minecraft (zumindest in neueren Versionen) –
+  // darum die Original-Einträge dieser Version übernehmen und die Symbole davorsetzen
+  try {
+    const eintrag = 'assets/minecraft/font/default.json';
+    const orig = JSON.parse(String((await ausJar(clientJar, [eintrag]))[eintrag] || '{"providers":[]}'));
+    const eigene = JSON.parse(String(asset('font_default.json'))).providers;
+    schreibe(path.join(ziel, 'assets', 'minecraft', 'font', 'default.json'),
+      JSON.stringify({ providers: [...eigene, ...(orig.providers || [])] }, null, 2));
+  } catch (err) {
+    if (protokoll) protokoll('[AeroMC] Symbole nicht eingebunden: ' + err.message);
+  }
+  for (const sprache of ['de_de', 'en_us']) {
+    const texte = Object.assign({},
+      design ? JSON.parse(String(asset(`lang_${sprache}.json`))) : {},
+      mods ? JSON.parse(String(asset(`lang_mods_${sprache}.json`))) : {});
+    schreibe(path.join(ziel, 'assets', 'minecraft', 'lang', sprache + '.json'), JSON.stringify(texte, null, 2));
+  }
+  // 26.x: „Feedback geben“ ist ein Symbol-Knopf -> Puzzle-Symbol für „Mods verwalten“
+  if (mods) schreibe(path.join(gui, 'sprites', 'pause_menu', 'social_interactions.png'), asset('mods_knopf.png'));
+  if (!design) { schreibe(marke, kennung); return; }
+
+  const titel = fs.readFileSync(path.join(ASSETS, alt ? 'titel_alt.png' : 'titel_neu.png'));
+  schreibe(path.join(gui, 'title', 'minecraft.png'), titel);
+  schreibe(path.join(gui, 'title', 'minceraft.png'), titel);
+  schreibe(path.join(gui, 'title', 'edition.png'), fs.readFileSync(path.join(ASSETS, alt ? 'edition_alt.png' : 'edition_neu.png')));
+  // Hintergrund des Hauptmenüs (Minecraft dreht ihn als Würfel um die Kamera)
+  for (let i = 0; i < 6; i++) {
+    schreibe(path.join(gui, 'title', 'background', `panorama_${i}.png`), fs.readFileSync(path.join(ASSETS, `panorama_${i}.png`)));
+  }
+  schreibe(path.join(ziel, 'assets', 'minecraft', 'texts', 'splashes.txt'), asset('splashes.txt'));
+
+  // Knöpfe wie im Entwurf (dunkles Schiefer, hervorgehoben leuchtend blau)
+  try {
+    if (ab(version, '1.20.2')) {
+      // eigene Sprites (doppelte Auflösung) samt Neun-Teile-Skalierung
+      const w = path.join(gui, 'sprites', 'widget');
+      schreibe(path.join(w, 'button.png'), asset('knopf.png'));
+      schreibe(path.join(w, 'button_highlighted.png'), asset('knopf_hell.png'));
+      schreibe(path.join(w, 'button.png.mcmeta'), asset('knopf.png.mcmeta'));
+      schreibe(path.join(w, 'button_highlighted.png.mcmeta'), asset('knopf.png.mcmeta'));
+    } else {
+      // widgets.png enthält auch Hotbar & Co. – Original 4-fach vergrößern (verlustfrei)
+      // und nur die Knopf-Zeilen durch die neuen ersetzen (66–86 normal, 86–106 hervorgehoben)
+      const e = 'assets/minecraft/textures/gui/widgets.png';
+      const daten = (await ausJar(clientJar, [e]))[e];
+      if (daten) {
+        const orig = pngLesen(daten);
+        const f = Math.max(1, Math.round(1024 / orig.w));
+        const W = orig.w * f, H = orig.h * f;
+        const gross = Buffer.alloc(W * H * 4);
+        for (let y = 0; y < H; y++) {
+          for (let x = 0; x < W; x++) orig.rgba.copy(gross, (y * W + x) * 4, (((y / f) | 0) * orig.w + ((x / f) | 0)) * 4, (((y / f) | 0) * orig.w + ((x / f) | 0)) * 4 + 4);
+        }
+        const s = W / 256;
+        for (const [datei, zeile] of [['knopf_4x.png', 66], ['knopf_hell_4x.png', 86]]) {
+          const k = pngLesen(asset(datei));
+          const kb = Math.round(200 * s), kh = Math.round(20 * s), y0 = Math.round(zeile * s);
+          for (let y = 0; y < kh; y++) {
+            for (let x = 0; x < kb; x++) {
+              const q = (((y * k.h / kh) | 0) * k.w + ((x * k.w / kb) | 0)) * 4;
+              k.rgba.copy(gross, ((y0 + y) * W + x) * 4, q, q + 4);
+            }
+          }
+        }
+        schreibe(path.join(gui, 'widgets.png'), pngSchreiben(W, H, gross));
+      }
+    }
+  } catch (err) {
+    if (protokoll) protokoll('[AeroMC] Knöpfe nicht ersetzt: ' + err.message);
+  }
+  schreibe(marke, kennung);
+}
+
+// ---------- options.txt ----------
+
+function liesListe(zeilen, schluessel) {
+  const z = zeilen.find((l) => l.startsWith(schluessel + ':'));
+  if (!z) return null;
+  try { const v = JSON.parse(z.slice(schluessel.length + 1)); return Array.isArray(v) ? v : []; } catch { return []; }
+}
+function setzeListe(zeilen, schluessel, liste) {
+  const i = zeilen.findIndex((l) => l.startsWith(schluessel + ':'));
+  const neu = schluessel + ':' + JSON.stringify(liste);
+  if (i >= 0) zeilen[i] = neu; else zeilen.push(neu);
+}
+
+/** Paket in options.txt ein- bzw. austragen. Rückgabe: ob sich etwas geändert hat. */
+function trageEin(gameDir, an) {
+  const datei = path.join(gameDir, 'options.txt');
+  let text = '';
+  try { text = fs.readFileSync(datei, 'utf8'); } catch { if (!an) return false; }
+  const zeilen = text ? text.split(/\r?\n/) : [];
+  while (zeilen.length && zeilen[zeilen.length - 1] === '') zeilen.pop();
+  const aktiv = liesListe(zeilen, 'resourcePacks') || ['vanilla'];
+  const unvertraeglich = liesListe(zeilen, 'incompatibleResourcePacks') || [];
+  const vorher = JSON.stringify([aktiv, unvertraeglich]);
+  const ohne = (l) => l.filter((p) => p !== PAKET_ID && p !== PAKET);
+  let a = ohne(aktiv), u = ohne(unvertraeglich);
+  if (an) {
+    // direkt über den eingebauten Paketen, unter allen eigenen Ressourcenpaketen
+    let pos = a.findIndex((p) => String(p).startsWith('file/'));
+    if (pos < 0) pos = a.length;
+    if (!a.includes('vanilla')) { a.unshift('vanilla'); pos++; }
+    a.splice(Math.max(pos, a.indexOf('vanilla') + 1), 0, PAKET_ID);
+    // NICHT in incompatibleResourcePacks eintragen: Steht ein passendes Paket dort,
+    // streicht Minecraft es aus der Liste und lässt es dabei für diesen Start weg
+  }
+  if (JSON.stringify([a, u]) === vorher) return false;
+  if (liesListe(zeilen, 'resourcePacks') || an) setzeListe(zeilen, 'resourcePacks', a);
+  if (liesListe(zeilen, 'incompatibleResourcePacks')) setzeListe(zeilen, 'incompatibleResourcePacks', u);
+  fs.writeFileSync(datei, zeilen.join('\n') + '\n');
+  return true;
+}
+
+// ---------- Einstieg ----------
+
+/**
+ * Vor jedem Spielstart: Paket anlegen und eintragen bzw. (ausgeschaltet)
+ * wieder entfernen. Fehler brechen den Start nie ab.
+ */
+async function vorbereiten({ gameDir, version, clientJar, an, mods, protokoll }) {
+  try {
+    if ((an || mods) && unterstuetzt(version)) {
+      await bauePaket(gameDir, version, clientJar, protokoll, { design: !!an, mods: !!mods });
+      trageEin(gameDir, true);
+    } else {
+      if (trageEin(gameDir, false) || fs.existsSync(path.join(gameDir, 'resourcepacks', PAKET))) {
+        fs.rmSync(path.join(gameDir, 'resourcepacks', PAKET), { recursive: true, force: true });
+      }
+    }
+  } catch (err) {
+    if (protokoll) protokoll('[AeroMC] Spieldesign nicht vorbereitet: ' + err.message);
+  }
+}
+
+/** Grafiken für den Agenten nach userData kopieren; Rückgabe: Ordner oder '' */
+function agentOrdner(userData) {
+  try {
+    const ordner = path.join(userData, 'agent', 'spieldesign');
+    fs.mkdirSync(ordner, { recursive: true });
+    for (const n of fs.readdirSync(ASSETS)) {
+      if (!/^(ladelogo(_alt)?\.png|icon_\d+\.rgba)$/.test(n)) continue;
+      const q = path.join(ASSETS, n), z = path.join(ordner, n);
+      const daten = fs.readFileSync(q);
+      let gleich = false;
+      try { gleich = fs.readFileSync(z).equals(daten); } catch { /* fehlt noch */ }
+      if (!gleich) fs.writeFileSync(z, daten);
+    }
+    return ordner;
+  } catch {
+    return '';
+  }
+}
+
+module.exports = { vorbereiten, agentOrdner, unterstuetzt, paketFormat, mcmeta, pngLesen, pngSchreiben, trageEin, PAKET_ID };

src/splash.html

@@ -0,0 +1,79 @@
+<!doctype html>
+<html lang="de">
+<head>
+  <meta charset="utf-8" />
+  <meta http-equiv="Content-Security-Policy"
+        content="default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; font-src 'self'" />
+  <title>AeroMC</title>
+  <style>
+    @font-face { font-family: 'AeroPixel'; src: url('assets/aeropixel.ttf'); }
+    html, body { margin: 0; height: 100%; overflow: hidden; background: transparent; user-select: none; cursor: default; }
+    body { font-family: 'Segoe UI', system-ui, sans-serif; }
+
+    /* Logo + Schriftzug in der Mitte */
+    .marke {
+      position: fixed; inset: 0; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 14px;
+      transition: opacity .28s ease, transform .32s ease;
+    }
+    .buehne { perspective: 700px; animation: rein .45s cubic-bezier(.2, .9, .3, 1.2) both; }
+    .logo {
+      width: 132px; height: 132px; display: block;
+      filter: drop-shadow(0 10px 26px rgba(0, 0, 0, .55)) drop-shadow(0 0 22px rgba(90, 160, 255, .35));
+      animation: drehen 1.3s cubic-bezier(.45, .05, .25, 1) .15s infinite;
+    }
+    .name {
+      font-size: 34px; font-weight: 600; letter-spacing: .06em; color: #fff;
+      text-shadow: 0 2px 10px rgba(0, 0, 0, .75), 0 0 2px rgba(0, 0, 0, .9);
+      animation: schrift .5s ease .25s both;
+    }
+    @keyframes rein { from { opacity: 0; transform: scale(.6); } to { opacity: 1; transform: none; } }
+    @keyframes drehen { from { transform: rotateY(0deg); } to { transform: rotateY(360deg); } }
+    @keyframes schrift { from { opacity: 0; transform: translateY(8px); letter-spacing: .3em; } to { opacity: 1; transform: none; letter-spacing: .06em; } }
+
+    /* Schriftzug je Design */
+    body[data-design="aero"] .name, body[data-design="lila"] .name {
+      background: linear-gradient(90deg, #7fe3ff, #6c9cff); -webkit-background-clip: text; background-clip: text; color: transparent;
+      text-shadow: none; filter: drop-shadow(0 2px 8px rgba(0, 0, 0, .8));
+    }
+    body[data-design="lila"] .name { background-image: linear-gradient(90deg, #e3b8ff, #9d7bff); }
+    body[data-design="lila"] .logo { filter: drop-shadow(0 10px 26px rgba(0, 0, 0, .55)) drop-shadow(0 0 22px rgba(170, 120, 255, .4)); }
+    body[data-design="minecraft"] .name {
+      font-family: 'AeroPixel', 'Segoe UI', sans-serif; font-weight: 400; font-size: 30px; letter-spacing: .04em;
+      text-shadow: 3px 3px 0 #3f3f3f, 0 0 10px rgba(0, 0, 0, .8);
+    }
+
+    /* das Launcher-Fenster als Bild, wächst von der Mitte nach außen */
+    #fenster { position: fixed; inset: 0; width: 100%; height: 100%; visibility: hidden; }
+    body.aufbau .marke { opacity: 0; transform: scale(.82); }
+  </style>
+</head>
+<body>
+  <div class="marke">
+    <div class="buehne"><img class="logo" src="assets/logo.png" alt="" /></div>
+    <div class="name">AeroMC</div>
+  </div>
+  <img id="fenster" alt="" />
+  <script>
+    document.body.dataset.design = new URLSearchParams(location.search).get('design') || 'dark';
+
+    // vom Hauptprozess aufgerufen: Bild des fertigen Launchers von der Mitte aus aufziehen
+    window.aufbauen = (bildAdresse) => new Promise((fertig) => {
+      const bild = document.getElementById('fenster');
+      bild.onerror = () => fertig(false);
+      bild.onload = () => {
+        const v = Math.max(0, innerHeight / 2 - 66);
+        const h = Math.max(0, innerWidth / 2 - 66);
+        bild.style.visibility = 'visible';
+        document.body.classList.add('aufbau');
+        bild.animate([
+          { clipPath: `inset(${v}px ${h}px round 30px)`, opacity: 0.2 },
+          { opacity: 1, offset: 0.25 },
+          { clipPath: 'inset(0px 0px round 0px)', opacity: 1 },
+        ], { duration: 560, easing: 'cubic-bezier(.2, .8, .2, 1)', fill: 'forwards' })
+          .finished.then(() => fertig(true), () => fertig(false));
+      };
+      bild.src = bildAdresse;
+    });
+  </script>
+</body>
+</html>

src/startanimation.js

@@ -0,0 +1,76 @@
+/*
+ * Startanimation des Hauptfensters (abschaltbar unter Optionen → Darstellung).
+ *
+ * Ablauf: Ein randloses, durchsichtiges Fenster liegt genau dort, wo der
+ * Launcher erscheinen wird, und zeigt das sich drehende Logo samt Schriftzug.
+ * Ist die Oberfläche fertig (renderer:ready), wird das noch unsichtbare
+ * Hauptfenster abfotografiert und dieses Bild im Startfenster von der Mitte
+ * nach außen aufgezogen. Am Ende übernimmt das echte Fenster an exakt
+ * derselben Stelle – dadurch wirkt es, als baue sich der Launcher auf.
+ */
+const path = require('path');
+const { BrowserWindow } = require('electron');
+
+const MINDESTENS_DREHEN_MS = 1600;  // so lange dreht sich das Logo mindestens
+const HOECHSTENS_WARTEN_MS = 8000;  // spätestens dann wird der Launcher gezeigt
+
+const warte = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// "renderer:ready" kommt, bevor Instanzliste und Kontoname gezeichnet sind –
+// erst darauf warten, sonst wächst ein halbleeres Fenster auf
+async function warteAufGezeichneteOberflaeche(wc) {
+  const pruefe = (ausdruck) => wc.executeJavaScript(ausdruck, true).catch(() => true);
+  // Liste gezeichnet – oder es gibt (noch) keine Instanzen, dann steht der Leer-Hinweis da
+  for (let i = 0; i < 30 && !(await pruefe("document.querySelectorAll('#grid > *').length > 0 || !document.getElementById('empty').classList.contains('hidden')")); i++) await warte(100);
+  for (let i = 0; i < 12 && !(await pruefe("(document.getElementById('account-name') || {}).textContent !== 'Konten'")); i++) await warte(100);
+  await warte(200);
+}
+
+async function spielen(hauptfenster, oberflaecheBereit, design) {
+  const b = hauptfenster.getContentBounds();
+  const start = new BrowserWindow({
+    x: b.x, y: b.y, width: b.width, height: b.height,
+    frame: false, transparent: true, resizable: false, movable: false,
+    minimizable: false, maximizable: false, fullscreenable: false,
+    skipTaskbar: true, hasShadow: false, focusable: false, show: false,
+    backgroundColor: '#00000000', title: 'AeroMC',
+    webPreferences: { contextIsolation: true, nodeIntegration: false, sandbox: true },
+  });
+
+  const launcherZeigen = () => {
+    if (hauptfenster.isDestroyed()) return;
+    hauptfenster.setOpacity(1);
+    hauptfenster.setIgnoreMouseEvents(false);
+    if (!hauptfenster.isVisible()) hauptfenster.show();
+    hauptfenster.focus();
+  };
+
+  try {
+    await start.loadFile(path.join(__dirname, 'splash.html'), { query: { design: design || 'dark' } });
+    start.showInactive();
+    const beginn = Date.now();
+    await Promise.race([oberflaecheBereit, warte(HOECHSTENS_WARTEN_MS)]);
+    const rest = MINDESTENS_DREHEN_MS - (Date.now() - beginn);
+    if (rest > 0) await warte(rest);
+    if (hauptfenster.isDestroyed()) return;
+
+    // Unsichtbar zeigen, damit Chromium die Oberfläche zeichnet, dann abfotografieren
+    hauptfenster.setOpacity(0);
+    hauptfenster.setIgnoreMouseEvents(true); // unsichtbar: Klicks gehen nicht versehentlich hinein
+    hauptfenster.show();
+    await warteAufGezeichneteOberflaeche(hauptfenster.webContents);
+    if (hauptfenster.isDestroyed()) return;
+    const bild = await hauptfenster.webContents.capturePage();
+    if (!bild.isEmpty() && !start.isDestroyed()) {
+      // höchstens 2,5 s – das Hauptfenster darf nie unsichtbar hängen bleiben
+      await Promise.race([start.webContents.executeJavaScript(`aufbauen(${JSON.stringify(bild.toDataURL())})`), warte(2500)]);
+    }
+  } catch {
+    // Animation ist nur Zierde – im Fehlerfall einfach den Launcher zeigen
+  } finally {
+    launcherZeigen();
+    setTimeout(() => { if (!start.isDestroyed()) start.destroy(); }, 80);
+  }
+}
+
+module.exports = { spielen };

src/store.js

@@ -78,7 +78,10 @@ const DEFAULT_SETTINGS = {
   desktopNotifications: true,  // Windows-Meldung bei fertigem Hintergrund-Download/-Backup
   friendsEnabled: true,
   friendsShareServer: true,    // Freunde sehen, auf welchem Server man spielt (für "Beitreten")
-  autoModUpdates: false,       // vor jedem Start Mods über Modrinth aktualisieren
+  autoModUpdates: false,
+  modSchalter: true,          // „Mods verwalten“ im Pausemenü (Instanzen mit Mod-Loader)
+  aeromcDesign: true,         // AeroMC-Look im Spiel: Ladebildschirm, Menü-Logo, Sprüche, Knöpfe, Fenstertitel
+  aeromcCapes: true,          // AeroMC-Umhänge im Spiel anzeigen (Umhang-Agent beim Start)       // vor jedem Start Mods über Modrinth aktualisieren
   schnellstart: {},            // Strg+1 … Strg+5 -> Instanz-ID ({ "1": "Survival", … })
   autoWorldBackup: true,       // nach jeder Spielsitzung die zuletzt gespielte Welt sichern (letzte 5 Stände)        // Freundesystem: eigene Online-Meldung + auffindbar für Anfragen
   friendNicknames: {},         // rein lokal: uuid -> eigener Spitzname für einen Freund
@@ -87,6 +90,8 @@ const DEFAULT_SETTINGS = {
   bgSkin: '',              // '' = aus, 'active' = aktives Konto, sonst Konto-UUID
   bgSkinOpacity: 55,       // Deckkraft des Hintergrund-Skins in %
   bgSkinPose: 'walking',   // Pose des 3D-Renders (falls der Pose-Dienst erreichbar ist)
+  startAnimation: true,    // drehendes Logo + Fensteraufbau beim Öffnen des Launchers
+  uiAnimationen: true,     // bewegte Oberfläche: lebende Skin-Figur, aufwachsende Fenster, Einblenden, Überblenden
   bgSkinModel: 'auto',     // Armform der Figur: 'auto' (vom Konto), 'classic' (Steve), 'slim' (Alex)
   bgSkinCycle: false,      // bei 2+ angemeldeten Konten automatisch durchwechseln
   bgSkinCycleSeconds: 30,  // Sekunden zwischen zwei Kontowechseln
@@ -113,13 +118,61 @@ function settingsFile() {
   return path.join(USER_DATA, 'settings.json');
 }
 
+/*
+ * Geheime Einstellungen (Proxy-Passwort, API-Schlüssel, Token) stehen nicht im
+ * Klartext in settings.json, sondern mit Windows-DPAPI verschlüsselt – genau
+ * wie die Konten (siehe auth.js). Nur dieses Windows-Konto kann sie lesen.
+ * Der Tresor kommt erst nach app.ready (safeStorage); bis dahin bleiben die
+ * verschlüsselten Werte unverändert stehen und werden so auch zurückgeschrieben.
+ */
+const GEHEIME_FELDER = ['proxyPass', 'curseforgeApiKey', 'curseforgeProxyToken'];
+const ENC = 'enc:v1:';
+let tresor = null;
+
+function bereit() {
+  try { return !!(tresor && tresor.available()); } catch { return false; }
+}
+
+function verschluesseln(obj) {
+  if (!bereit()) return obj;
+  const o = Object.assign({}, obj);
+  for (const k of GEHEIME_FELDER) {
+    if (typeof o[k] === 'string' && o[k] && !o[k].startsWith(ENC)) o[k] = ENC + tresor.encrypt(o[k]);
+  }
+  return o;
+}
+
+function entschluesseln(obj) {
+  if (!bereit()) return obj;
+  const o = Object.assign({}, obj);
+  for (const k of GEHEIME_FELDER) {
+    if (typeof o[k] === 'string' && o[k].startsWith(ENC)) {
+      // nicht lesbar (z. B. Sicherung von einem anderen PC) -> neu eingeben lassen
+      try { o[k] = tresor.decrypt(o[k].slice(ENC.length)); } catch { o[k] = ''; }
+    }
+  }
+  return o;
+}
+
+// Wird nach app.ready aufgerufen; stellt vorhandene Klartext-Werte sofort um
+function setzeTresor(t) {
+  tresor = t;
+  if (!bereit()) return;
+  try {
+    const roh = readJson(settingsFile(), null);
+    if (roh && GEHEIME_FELDER.some((k) => typeof roh[k] === 'string' && roh[k] && !roh[k].startsWith(ENC))) {
+      writeJson(settingsFile(), verschluesseln(roh));
+    }
+  } catch { /* beim nächsten Speichern erneut */ }
+}
+
 function getSettings() {
-  return Object.assign({}, DEFAULT_SETTINGS, readJson(settingsFile(), {}));
+  return Object.assign({}, DEFAULT_SETTINGS, entschluesseln(readJson(settingsFile(), {})));
 }
 
 function saveSettings(patch) {
   const merged = Object.assign({}, getSettings(), patch || {});
-  writeJson(settingsFile(), merged);
+  writeJson(settingsFile(), verschluesseln(merged));
   // Falls sich das Instanzverzeichnis geändert hat: sicherstellen, dass es existiert
   ensureDir(getInstancesDir());
   return merged;
@@ -423,6 +476,35 @@ function createInstance(data) {
   return writeInstance(inst);
 }
 
+/*
+ * Große Instanzordner nicht synchron löschen (das fror den Launcher bei vielen
+ * GB minutenlang ein): sofort in einen versteckten Papierkorb im Instanzordner
+ * verschieben – das ist nur eine Umbenennung – und dort im Hintergrund löschen.
+ * Reste (z. B. nach einem Absturz) räumt raeumePapierkorbAuf() beim Start weg.
+ */
+const PAPIERKORB = '.aeromc-papierkorb';
+function entsorgeOrdner(p) {
+  if (!fs.existsSync(p)) return;
+  const korb = path.join(path.dirname(p), PAPIERKORB);
+  const ziel = path.join(korb, path.basename(p) + '-' + Date.now());
+  try {
+    ensureDir(korb);
+    fs.renameSync(p, ziel);
+  } catch {
+    // Umbenennen klappt nicht (z. B. Datei gerade geöffnet): instance.json sofort
+    // weg, damit die Instanz aus der Liste verschwindet – den Rest im Hintergrund
+    try { fs.rmSync(path.join(p, 'instance.json'), { force: true }); } catch { /* egal */ }
+    fs.promises.rm(p, { recursive: true, force: true }).catch(() => { /* bleibt liegen, stört nicht */ });
+    return;
+  }
+  fs.promises.rm(ziel, { recursive: true, force: true }).catch(() => { /* beim nächsten Start erneut */ });
+}
+
+function raeumePapierkorbAuf() {
+  const korb = path.join(getInstancesDir(), PAPIERKORB);
+  if (fs.existsSync(korb)) fs.promises.rm(korb, { recursive: true, force: true }).catch(() => {});
+}
+
 function createOrReplaceImportedInstance(data) {
   const existing = findInstanceByName(data && data.name);
   if (!existing) return createInstance(data);
@@ -434,8 +516,7 @@ function createOrReplaceImportedInstance(data) {
   inst.totalPlaySeconds = existing.totalPlaySeconds || 0;
   inst.launchCount = existing.launchCount || 0;
 
-  const p = instancePath(existing.id);
+  entsorgeOrdner(instancePath(existing.id));
-  if (fs.existsSync(p)) fs.rmSync(p, { recursive: true, force: true });
   return writeInstance(inst);
 }
 
@@ -451,12 +532,11 @@ function updateInstance(id, patch) {
 }
 
 function deleteInstance(id) {
-  const p = instancePath(id);
+  entsorgeOrdner(instancePath(id));
-  if (fs.existsSync(p)) fs.rmSync(p, { recursive: true, force: true });
   return true;
 }
 
-function duplicateInstance(id) {
+function duplicateInstance(id, ohneSpieldaten) {
   const src = getInstance(id);
   if (!src) throw new Error('Instanz nicht gefunden: ' + id);
   const copy = JSON.parse(JSON.stringify(src));
@@ -468,9 +548,11 @@ function duplicateInstance(id) {
   copy.launchCount = 0;
   ensureDir(gameDir(copy.id));
   // Spielinhalte mitkopieren (Mods/Configs) – ohne Fehler wenn leer
+  if (!ohneSpieldaten) {
     try {
       fs.cpSync(gameDir(id), gameDir(copy.id), { recursive: true });
     } catch { /* Quelle evtl. leer */ }
+  }
   writeJson(instanceFile(copy.id), copy);
   return copy;
 }
@@ -478,6 +560,7 @@ function duplicateInstance(id) {
 module.exports = {
   init,
   getSettings,
+  setzeTresor,
   saveSettings,
   getInstancesDir,
   instancePath,
@@ -498,6 +581,8 @@ module.exports = {
   createInstance,
   createOrReplaceImportedInstance,
   updateInstance,
+  uniqueFolderId,
   deleteInstance,
+  raeumePapierkorbAuf,
   duplicateInstance,
 };