Modpacks verwalten

Modpacks verwalten

Installiertes Modpack anzeigen, auf neue Versionen aktualisieren, Modpacks wechseln und das Tracking-System verstehen.

Installiertes Modpack anzeigen

Der Installiert-Tab zeigt Informationen zum aktuell installierten Modpack:

Diese Daten stammen aus .installed_modpack.json im Server-Root.

Modpack aktualisieren

Wie die Update-Erkennung funktioniert

Beim Betrachten eines bereits installierten Modpacks:

1. Plugin liest .installed_modpack.json für aktuelle Version
2. Vergleicht mit verfügbaren Versionen vom Anbieter
3. Neuere Versionen werden mit Update-Option angezeigt

Update-Optionen

Beim Aktualisieren (🟠-Typ) gibt es zwei Möglichkeiten:

Empfohlen: „Konfigurationen behalten" für die meisten Updates — bewahrt deine Anpassungen.

Nach dem Update

1. Warten bis der 8-Schritte-Fortschritt abgeschlossen ist
2. Server neustarten
3. Überprüfen ob das Modpack korrekt lädt
4. Zusammengeführte Konfigurationen auf Probleme prüfen

Zu einem anderen Modpack wechseln

Modpack wechseln (🔴-Typ) ist die destruktivste Operation:

1. Vollständiges Backup wird automatisch erstellt
2. Alle Dateien gelöscht (außer Welten, Plugins, Logs)
3. Plugin-übergreifende Bereinigung läuft (Game Mods + Minecraft Plugins Daten gelöscht)
4. Neues Modpack heruntergeladen und installiert
5. Wichtige Dateien wiederhergestellt

Warnung: Modpack-Wechsel löscht alle Mod- und Plugin-Tracking-Daten anderer Eranio-Plugins.

Aktuelles Modpack neu installieren

Neuinstallation (🔵-Typ) lädt das gleiche Modpack und die gleiche Version erneut herunter:

• Nützlich zur Reparatur beschädigter Installationen
• Backup wird vor der Neuinstallation erstellt
• Konfigurationen können behalten oder ersetzt werden

Konsolen-Widget

Ein Widget auf der Server-Konsolenseite verfolgt den Modpack-Status:

• Cache: 5 Minuten für Update-Prüfungen
• Zeigt installierte Modpack-Informationen
• Warnt wenn Updates verfügbar sind mit Weiterleitung zum Modpack Browser

Fehlerbehebung

„.installed_modpack.json" fehlt

• Noch kein Modpack über das Plugin installiert
• Datei wurde manuell gelöscht
• Plugin behandelt dies als Erstinstallation

Modpack lädt aber stürzt beim Start ab

1. Serverkonsole auf Fehlermeldungen prüfen
2. Java-Version stimmt mit Modpack-Anforderungen überein? (8, 11, 16, 17 oder 21)
3. RAM-Zuweisung prüfen — Modpacks brauchen oft 4-8+ GB
4. Mod-Loader-Versionskompatibilität verifizieren
5. Neuinstallation mit „Konfigurationen löschen" versuchen

Konfigurationszusammenführung hat Probleme verursacht

• Manche Mods ändern das Konfig-Format zwischen Versionen — Merge kann Konflikte verursachen
• Lösung: Neuinstallation mit „Konfigurationen löschen", dann Änderungen manuell erneut anwenden

Server hängt auf Installer-Egg

• Installation ist möglicherweise bei Schritt 4-5 fehlgeschlagen
• Egg manuell zurück zum Runtime in Admin Panel → Server → [Server] → Build wechseln
• Logs auf Timeout- oder Download-Fehler prüfen

⚠️ „Cache leeren" löscht alles

• clearCache() des Modpack-Plugins verwendet Cache::flush() — eine globale Cache-Leerung
• Dies löscht ALLE gecachten Daten für ALLE Plugins und das gesamte Panel
• Nach dem Leeren: andere Plugins können langsam sein bis ihre Caches sich wieder aufbauen
• Sparsam verwenden — bevorzuge Warten auf TTL-Ablauf wenn möglich

Interne Provider-Funktionen (Referenz)

Dieser Abschnitt dokumentiert den internen PHP-Code für jede Provider-Integration, einschließlich API-Parameter, Antwort-Schemata, Rate-Limits und Verarbeitungslogik.

CurseForge Provider (Modpacks) — Vollständige Referenz

Verwendet die gleiche CurseForge-API wie die anderen Plugins, aber mit classId=4471 (Modpacks).

API-Endpunkt-Parameter — GET /v1/mods/search

Antwort-Schema — Suchergebnisse

Rate-Limits

// Modpack-Suche (classId=4471) — einziger Unterschied zu Mods/Plugins
$response = Http::withHeaders(['x-api-key' => $apiKey])
    ->timeout($timeout)
    ->get('https://api.curseforge.com/v1/mods/search', [
        'gameId'        => 432,      // Minecraft
        'classId'       => 4471,     // ⚠ Modpacks — NICHT 9137 (Mods) oder 5 (Plugins)!
        'searchFilter'  => $query,
        'sortField'     => $query ? 1 : 2,
        'sortOrder'     => 'desc',
        'gameVersion'   => $mcVersion,
        'pageSize'      => $perPage,
        'index'         => ($page - 1) * $perPage,
    ]);

// Antwortverarbeitung — Modpacks zu Kartendaten
$results = $response->json('data', []);
$packs = collect($results)->map(function ($mod) {
    return [
        'id'         => $mod['id'],
        'name'       => $mod['name'],
        'slug'       => $mod['slug'],
        'summary'    => $mod['summary'],
        'author'     => $mod['authors'][0]['name'] ?? 'Unbekannt',
        'downloads'  => $mod['downloadCount'],
        'icon_url'   => $mod['logo']['url'] ?? null,
        'provider'   => 'curseforge',
    ];
});

// Server-Pack-Erkennung — bevorzuge Server-Pack statt Client-Pack
// Manche CurseForge-Modpacks bieten eine separate „Server-Pack"-Datei
if (!empty($fileData['serverPackFileId'])) {
    $serverPack = $this->getFile($modId, $fileData['serverPackFileId']);
    // Server-Pack für Server-Installationen verwenden — kleiner, ohne Client-seitige Mods
}

// Modpack-Dateistruktur — overrides/-Ordner + manifest.json
// CurseForge-Modpacks enthalten Murmur2-fingerprinted Module
foreach ($file['modules'] as $module) {
    // module['name']        => z.B. "overrides", "manifest.json"
    // module['fingerprint'] => Murmur2-Hash zur Dateiintegritätsprüfung
    // overrides/-Ordner wird ins Server-Stammverzeichnis extrahiert
}

CurseForge Modpacks Provider-Fehlertabelle

Modrinth Provider (Modpacks) — Vollständige Referenz

API-Endpunkt-Parameter — GET /v2/search

Modpack-spezifische Facetten

// Das Plugin baut Facetten speziell für Modpacks
$facets = [
    ['project_type:modpack'],                    // Muss Modpack sein, nicht Mod/Plugin
];
if ($mcVersion) $facets[] = ["versions:$mcVersion"];
if ($loader)    $facets[] = ["categories:$loader"];  // z.B. categories:forge

$params['facets'] = json_encode($facets);

Antwort-Schema — Suchergebnisse

Rate-Limits

// Modpack-Suche mit Modpack-spezifischen Facetten
$response = Http::timeout($timeout)
    ->get('https://api.modrinth.com/v2/search', [
        'query'  => $query,
        'facets' => json_encode([
            ['project_type:modpack'],
            $mcVersion ? ["versions:$mcVersion"] : [],
            $loader ? ["categories:$loader"] : [],
        ]),
        'limit'  => $perPage,
        'offset' => ($page - 1) * $perPage,
    ]);

// Antwortverarbeitung
$hits = $response->json('hits', []);
$packs = collect($hits)->map(function ($hit) {
    return [
        'id'         => $hit['project_id'],
        'name'       => $hit['title'],
        'slug'       => $hit['slug'],
        'summary'    => $hit['description'],
        'author'     => $hit['author'],
        'downloads'  => $hit['downloads'],
        'icon_url'   => $hit['icon_url'] ?? null,
        'versions'   => $hit['versions'] ?? [],
        'provider'   => 'modrinth',
    ];
});

// Modrinth-Modpacks verwenden .mrpack-Format (ZIP-Datei)
// Struktur: modrinth.index.json + overrides/
$manifest = json_decode($zip->getFromName('modrinth.index.json'), true);
foreach ($manifest['files'] as $file) {
    // $file['path']            => Zielpfad relativ zum Server-Stammverzeichnis
    // $file['downloads']       => Array von Download-Mirror-URLs
    // $file['hashes']['sha1']  => SHA-1 zur Integritätsprüfung
    // $file['hashes']['sha512'] => SHA-512 zur Integritätsprüfung
    // $file['fileSize']        => Erwartete Dateigröße in Bytes
}
// overrides/-Verzeichnis wird ins Server-Stammverzeichnis extrahiert

Modrinth Modpacks Provider-Fehlertabelle

FeedTheBeast (FTB) Provider — Vollständige Referenz

FTB API unter https://api.feed-the-beast.com/v1. Keine Authentifizierung nötig. Verwendet ein einzigartiges zweistufiges Lademuster.

API-Endpunkt-Parameter — GET /v1/modpacks/public/modpack/all

API-Endpunkt-Parameter — GET /v1/modpacks/public/modpack/{packId}

API-Endpunkt-Parameter — GET /v1/modpacks/public/modpack/search/{limit}

Antwort-Schema — Alle Packs

Antwort-Schema — Pack-Details

Antwort-Schema — Suche

Rate-Limits

// Schritt 1: Alle FTB Pack-IDs abrufen
$all = Http::timeout($timeout)
    ->get('https://api.feed-the-beast.com/v1/modpacks/public/modpack/all');
// Gibt zurück: { "packs": [100, 200, 300, ...], "total": 150 }
// ⚠ Pack-ID 81 ist FTBs Test-Pack — MUSS herausgefiltert werden!
$packIds = collect($all->json('packs', []))->reject(fn ($id) => $id === 81);

// Schritt 2: Details für jedes Pack abrufen (gebatcht mit Parallelitätskontrolle)
$packs = $packIds->map(function ($id) use ($timeout) {
    $pack = Http::timeout($timeout)
        ->get("https://api.feed-the-beast.com/v1/modpacks/public/modpack/{$id}")
        ->json();

    return [
        'id'         => $pack['id'],
        'name'       => $pack['name'],
        'summary'    => $pack['synopsis'] ?? '',
        'icon_url'   => collect($pack['art'] ?? [])->firstWhere('type', 'square')['url'] ?? null,
        'downloads'  => $pack['installs'] ?? 0,
        'versions'   => collect($pack['versions'] ?? [])->pluck('name')->toArray(),
        'provider'   => 'ftb',
    ];
});

// FTB-Packs durchsuchen — gibt Pack-IDs zurück, dann Details abrufen
$search = Http::timeout($timeout)
    ->get("https://api.feed-the-beast.com/v1/modpacks/public/modpack/search/100", [
        'term' => $query,
    ]);
// Gibt zurück: { "packs": [100, 200], "curseforge": [], "total": 2 }
// Das numerische Suffix (100) ist die maximale Ergebnisanzahl
// "curseforge"-Array enthält querverweisende CurseForge-Mod-IDs

// Server-Pack-Download — benötigt Versions-ID für plattformspezifischen Download
$serverUrl = "https://api.feed-the-beast.com/v1/modpacks/public/modpack/{$packId}/versions/{$versionId}/server/linux";
// Alternative: .../server/windows für Windows-Server
// Lädt ein Server-Installer-Skript/ZIP herunter

FTB-spezifisches Verhalten:

• Zweistufiges Laden: Erst GET .../all für IDs → dann GET .../{id} pro Pack für Details
• Suche gibt Pack-IDs zurück (keine vollständigen Objekte) — erfordert zweiten Schritt für Details
• Pack-ID 81 wird immer herausgefiltert — es ist FTBs internes Test-Pack
• art-Array hat type: "square" (Logo) und type: "splash" (Banner)
• status: "released" = öffentlich; "private" = braucht speziellen Zugangscode
• Server-Downloads sind plattformspezifisch: /server/linux oder /server/windows
• Versions-type kann "Release", "Beta" oder "Alpha" sein — standardmäßig nur Release angezeigt
• Modpack-Daten werden 24 Stunden pro Pack gecacht

FTB Provider-Fehlertabelle

Technic Platform Provider — Vollständige Referenz

Technic API unter https://api.technicpack.net. Benötigt einen build-Parameter für Launcher-Versionskompatibilität.

API-Endpunkt-Parameter — GET /search/modpacks/{query}

API-Endpunkt-Parameter — GET /modpack/{slug}

Antwort-Schema — Suche (Dictionary-Format!)

Antwort-Schema — Pack-Details

Rate-Limits

// Technic Modpacks durchsuchen — beachte Dictionary-Antwortformat
$response = Http::timeout($timeout)
    ->get("https://api.technicpack.net/search/modpacks/{$query}", [
        'build' => 822,  // ⚠ Muss eine gültige Technic Launcher Build-Nummer sein!
    ]);

// WICHTIG: Technic gibt ein DICTIONARY nach Slug zurück, kein Array!
$modpacks = $response->json('modpacks', []);
// $modpacks = { "tekkit": { ... }, "hexxit": { ... } }
// Muss array_values() oder collect() zum Iterieren verwenden
$packs = collect($modpacks)->map(function ($pack, $slug) {
    return [
        'id'         => $slug,
        'name'       => $pack['displayName'] ?? $pack['name'],
        'summary'    => '', // Technic-Suche liefert keine Beschreibungen
        'downloads'  => $pack['runs'] ?? 0,
        'mc_version' => $pack['minecraft'] ?? 'Unbekannt',
        'provider'   => 'technic',
    ];
});

// Spezifische Modpack-Details abrufen — enthält Download-URL
$pack = Http::timeout($timeout)
    ->get("https://api.technicpack.net/modpack/{$slug}", [
        'build' => 822,
    ])->json();

// Antwortverarbeitung — Pack-Metadaten extrahieren
$result = [
    'name'        => $pack['displayName'] ?? $pack['name'],
    'url'         => $pack['url'],              // Direkte ZIP-Download-URL
    'platform'    => $pack['platformUrl'],       // Technic-Website-Seite
    'mc_version'  => $pack['minecraft'] ?? '',   // MC-Versionsstring
    'runs'        => $pack['runs'] ?? 0,
    'icon'        => $pack['icon']['url'] ?? null,
    'logo'        => $pack['logo']['url'] ?? null,
];
// url-Feld → direkter Download des Modpack-ZIP (Server oder Client)

Technic-spezifisches Verhalten:

• Suche gibt ein Dictionary nach Slug zurück, kein Array — muss konvertiert werden
• build-Parameter ist erforderlich — steuert API-Kompatibilitätsversion
• minecraft-Feld enthält den MC-Versionsstring direkt (kein Array)
• platformUrl verlinkt zur Technic-Website-Seite für das Pack
• url-Feld → direkter ZIP-Download (für Client und Server gleich)
• runs zählt die Anzahl der Modpack-Starts (nicht Downloads)
• Keine server-spezifischen Packs — gleiche ZIP für Client und Server; manuelle Extraktion nötig
• Keine Paginierung — Suche gibt alle passenden Packs auf einmal zurück

Technic Provider-Fehlertabelle

ATLauncher Provider — Vollständige Referenz

ATLauncher verwendet eine GraphQL-API unter https://api.atlauncher.com/v2/graphql. Dies ist der einzige GraphQL-basierte Provider.

GraphQL-Endpunkt — POST /v2/graphql

Verfügbare Abfragefelder

Rate-Limits

// GraphQL-Abfrage für ATLauncher Pack-Auflistung
$query = <<<'GRAPHQL'
{
    packs(first: 20) {
        edges {
            node {
                id
                name
                description
                type
                versions {
                    version
                    minecraft
                }
            }
        }
    }
}
GRAPHQL;

$response = Http::timeout($timeout)
    ->post('https://api.atlauncher.com/v2/graphql', ['query' => $query]);

// Antwortverarbeitung für ATLauncher GraphQL
$data = $response->json('data.packs.edges', []);
$packs = collect($data)->map(function ($edge) {
    $node = $edge['node'];
    $latestVersion = collect($node['versions'] ?? [])->first();
    return [
        'id'         => $node['id'],
        'name'       => $node['name'],
        'summary'    => Str::limit($node['description'] ?? '', 200),
        'mc_version' => $latestVersion['minecraft'] ?? 'Unbekannt',
        'pack_version' => $latestVersion['version'] ?? '',
        'type'       => $node['type'],  // "public", "semi-public", "private"
        'provider'   => 'atlauncher',
    ];
})->filter(fn ($p) => $p['type'] === 'public');  // Nur öffentliche Packs anzeigen

// Server-Download-URL-Muster — benötigt exakten Pack-Namen und Version
$serverUrl = "https://servers.atlauncher.com/server/{$packName}/{$version}";
// Nicht alle Packs haben Server-Distributionsrechte — 404 wenn nicht verfügbar

ATLauncher-spezifisches Verhalten:

• Nur GraphQL — keine REST-API-Endpunkte verfügbar
• Pack-Typen: "public" (offen), "semi-public" (braucht Code), "private" (eingeschränkt)
• Nur "public"-Packs in der Standardliste — clientseitig gefiltert
• Server-Downloads auf servers.atlauncher.com — nicht alle Packs haben Server-Distribution
• GraphQL-Abfragen haben höheren Overhead als REST — langsamere Antwortzeiten erwartet
• Versionsliste enthält MC-Versions-Zuordnung pro Pack-Version
• Kein Such-Endpunkt — Filterung erfolgt clientseitig auf der zurückgegebenen Liste
• description kann HTML enthalten — für Anzeige zu Klartext umgewandelt

ATLauncher Provider-Fehlertabelle

VoidsWrath Provider — Vollständige Referenz

VoidsWrath verwendet eine statische JSON-Datei — keine dynamische API, keine Suche, keine Paginierung.

API-Endpunkt — GET /minecraft-modpack-server-installer/voidswrath.json

Antwort-Schema — Pack-Array

Rate-Limits

// Gesamten VoidsWrath-Katalog abrufen — eine Anfrage, alle Packs
$response = Http::timeout($timeout)
    ->get('https://www.ric-rac.org/minecraft-modpack-server-installer/voidswrath.json');

$allPacks = $response->json();
// Gibt zurück: Vollständiges Array aller Packs — typischerweise <20 Einträge

// Antwortverarbeitung — keine Filterung nötig
$packs = collect($allPacks)->map(function ($pack) {
    return [
        'id'         => Str::slug($pack['name']),         // Generierter Slug
        'name'       => $pack['name'],
        'summary'    => $pack['description'] ?? '',
        'mc_version' => $pack['mcVersion'] ?? 'Unbekannt',
        'version'    => $pack['version'] ?? '',
        'icon_url'   => $pack['icon'] ?? null,
        'download'   => $pack['url'],                      // Direkte ZIP-URL
        'server_url' => $pack['serverUrl'] ?? null,        // Server-spezifische URL
        'provider'   => 'voidswrath',
    ];
});

VoidsWrath-spezifisches Verhalten:

• Keine Suche — alle Packs werden auf einmal aus einer einzigen statischen JSON-Datei geladen
• Keine Paginierung — gesamter Katalog in einer Anfrage (typischerweise <20 Packs)
• Keine API-Versionierung — wenn sich die JSON-Struktur ändert, kann das Abrufen fehlschlagen
• Downloads zeigen direkt auf ZIP-Dateien — kein CDN oder Mirror-System
• Pack-Updates erfordern vollständigen Neu-Download — keine differenzielle/inkrementelle Updates
• serverUrl kann null sein für Packs ohne Server-Distribution
• Statische Datei auf ric-rac.org gehostet — Verfügbarkeit hängt von diesem einzelnen Host ab
• Sehr kleiner Katalog im Vergleich zu anderen Providern
• Cache-TTL sollte großzügig sein (24h+), da sich Daten selten ändern

VoidsWrath Provider-Fehlertabelle

Providerübergreifende Muster (Modpacks)

// Modpack-Installationsablauf (alle Provider)
// 1. Pack-Archiv herunterladen (ZIP/mrpack)
// 2. Zum Installer-Egg wechseln falls nötig
// 3. Ins Server-Verzeichnis extrahieren
// 4. Konfigurationen zusammenführen (bei Update)
// 5. Zurück zum Game-Egg wechseln
// 6. Game Mods + Plugins Daten löschen (Plugin-übergreifende Bereinigung)

// Backup vor Installation — erstellt zeitgestempeltes Archiv
$backupName = "backup_" . date('Y-m-d_H-i-s') . ".tar.gz";
// Bei fehlgeschlagenem Backup wird die Installation mit Warnung fortgesetzt

// Such-Wiederholungslogik — gleich wie bei anderen Plugins
$results = $this->search($query, $mcVersion, $loader);
if (empty($results) && $mcVersion) {
    $results = $this->search($query, null, $loader);
    // Wiederholung ohne Versionsfilter — Version evtl. noch nicht indiziert
}

Vollständige Benachrichtigungs-Referenz

HTTP-Fehlercode-Referenz (Alle Provider)

Provider-spezifische Fehlertabelle

CurseForge (Modpacks) Fehler

Modrinth (Modpacks) Fehler

FTB Fehler

Technic Fehler

ATLauncher Fehler

VoidsWrath Fehler