Mr UltraHD
📎 1 file 11,701 chars
📄
pasted-code-1792433928771.txt
txt 279 lines
▶
# Entwickle ein vollständiges Minecraft-Paper-Plugin: MiniCityServerSelector

Programmiere ein vollständiges, funktionsfähiges Minecraft-Plugin für **Paper 1.21.11 mit Java 21 oder einer kompatiblen Java-Version**. Das Plugin soll ein einzigartiges Serverauswahl-System mit einer kleinen Miniaturstadt aus vier Custom-Blöcken, einem scrollbaren GUI-Menü, sechs konfigurierbaren Servern und vollständig anpassbaren Nachrichten erstellen.

Das Plugin soll speziell für ein Minecraft-Servernetzwerk mit Velocity-Proxy entwickelt werden.

## 1. Allgemeine Anforderungen

- Pluginname: `MiniCityServerSelector`
- Hauptklasse und Package-Struktur sauber und professionell aufbauen.
- Erstelle den vollständigen Java-Quellcode und alle benötigten Dateien.
- Verwende eine `plugin.yml` und eine `config.yml`.
- Nutze keine kostenpflichtigen APIs oder externen Dienste.
- Das Plugin muss auf Paper 1.21.11 funktionieren.
- Erstelle ein fertiges Maven- oder Gradle-Projekt, das sich zu einer installierbaren `.jar` kompilieren lässt.
- Alle Nachrichten, Farben, Sounds, Texte, Blöcke, Servernamen und GUI-Einstellungen müssen konfigurierbar sein.
- Unterstütze Minecraft-Hex-Farben wie `#FF5500`, `#FFFFFF` und Minecraft-MiniMessage-Farbcodes.
- Der Code muss stabil, performant und gut strukturiert sein.

## 2. Command `/code`

Erstelle den Command:

`/code`

Mit folgendem Aufruf:

`/code 2309 80 4`

soll der Spieler **vier spezielle Custom-Blöcke** erhalten.

Die drei Zahlen sollen als konfigurierbare Parameter behandelt werden. Verwende zunächst `2309`, `80` und `4` als Beispielwerte. Da Minecraft keine frei definierbaren Block-IDs wie ältere Versionen besitzt, implementiere die Custom-Blöcke mit einer geeigneten modernen Methode, beispielsweise über Custom-Items mit CustomModelData, Resourcepack-Modelle oder eine andere kompatible Lösung.

Anforderungen:

- Gib dem Spieler genau vier zusammengehörige Blöcke.
- Jeder Block soll eine eigene Custom-Textur und ein eigenes 3D-Modell besitzen.
- Die Blöcke sollen optisch zusammenpassen, wenn sie nebeneinander platziert werden.
- Verwende eindeutige Kennzeichnungen in den Item-Metadaten, damit das Plugin diese Blöcke zuverlässig erkennt.
- Normale Minecraft-Blöcke dürfen nicht versehentlich als Custom-Blöcke erkannt werden.
- Nur Spieler mit einer konfigurierbaren Permission dürfen den Command verwenden.
- Füge Tab-Completion und konfigurierbare Fehlermeldungen hinzu.

## 3. Vier Blöcke ergeben eine Miniaturstadt

Die vier speziellen Blöcke sollen zusammen eine kleine, zusammenhängende Miniaturstadt darstellen.

Stelle die vier Teile als zusammengehöriges Stadtmodell dar:

- Teil 1: Stadtgebäude und Straßeneingang
- Teil 2: weitere Gebäude und Straße
- Teil 3: kleine Landschaft mit Bäumen und Dekoration
- Teil 4: zentrale Plaza mit Serverauswahl-Element

Die Stadt soll möglichst wie ein einziges zusammenhängendes Modell wirken, wenn alle vier Teile direkt nebeneinander platziert werden.

Wichtig: Verwende keine erfundenen Vanilla-Block-IDs. Falls ein echtes Custom-Block-System notwendig ist, nutze eine technisch geeignete Lösung für Paper 1.21.11. Erkläre, ob dafür ein Resourcepack erforderlich ist.

Wenn eine vollständig frei platzierbare Custom-Block-Implementierung mit der Paper-API allein nicht möglich ist, verwende eine stabile Alternative, etwa Display-Entities oder ein anderes geeignetes Modell-System. Die vier Teile sollen sich trotzdem wie ein zusammengehöriges Stadtmodell verhalten.

## 4. Interaktion mit der Miniaturstadt

Wenn ein Spieler die Miniaturstadt berührt oder auf das vorgesehene Interaktionsfeld klickt, soll sich ein großes Serverauswahl-Menü öffnen.

- Verhindere, dass die Interaktion mehrfach gleichzeitig ausgelöst wird.
- Stelle sicher, dass andere Spieler das Menü unabhängig voneinander öffnen können.
- Die Menüöffnung muss über die Config aktivierbar und deaktivierbar sein.
- Verwende konfigurierbare Sounds und Partikeleffekte.
- Das Menü darf keine Gegenstände aus dem Inventar des Spielers verlieren lassen.
- Das Menü muss sicher gegen unerlaubtes Verschieben und Herausnehmen von GUI-Items sein.

## 5. Großes Serverauswahl-GUI

Erstelle ein optisch hochwertiges, modernes Serverauswahl-Menü.

Es soll sechs Server enthalten:

- SV1
- SV2
- SV3
- SV4
- SV5
- SV6

Anforderungen:

- Das Menü soll übersichtlich, modern und im Minecraft-Stil gestaltet sein.
- Die Serverauswahl soll scrollbar sein. Nutze dafür ein geeignetes Chest-GUI mit Seitenwechseln oder ein anderes kompatibles Inventar-System.
- Unterstütze Suche nach Servernamen, falls technisch sinnvoll.
- Jeder Server soll einen eigenen konfigurierbaren Button besitzen.
- Jeder Button soll eine eigene Hintergrundfarbe und ein eigenes Material haben.
- Der Name des Buttons soll beispielsweise `SV1`, `SV2` usw. lauten.
- Die Beschriftungen sollen mit einer passenden Minecraft-Schrift und konfigurierbaren Farben dargestellt werden.
- Unterstütze benutzerdefinierte Items, CustomModelData und Resourcepack-Modelle.
- Zeige unter dem Servernamen den konfigurierten Status `Online` oder `Offline`.
- Alle Slots, Titel, Materialien, Farben, Texte und Sounds müssen in der Config bearbeitbar sein.
- Das GUI soll aufgeräumt aussehen und auch bei mehreren Seiten zuverlässig funktionieren.

## 6. Serverstatus und Statusfarben

Jeder Server muss einen eigenen Status besitzen.

Für jeden Server sollen folgende Optionen konfigurierbar sein:

- Servername
- Velocity-Server-ID
- Anzeigename im Menü
- Aktiviert oder deaktiviert
- Online- oder Offline-Status
- Material des Buttons
- Button-Hintergrundfarbe
- Textfarbe
- Statusfarbe für Online
- Statusfarbe für Offline
- Slotposition
- Zielserver oder auszuführender Befehl
- Nachricht bei erfolgreicher oder fehlgeschlagener Verbindung

Beispiel für die Config:

```yaml
servers:
  SV1:
    enabled: true
    display-name: "SV1"
    velocity-server: "smp"
    status:
      online-text: "Online"
      offline-text: "Offline"
    status-check:
      enabled: true
      interval-seconds: 10
    button:
      material: "GRASS_BLOCK"
      slot: 11
      background-color: "#FF5500"
    action:
      type: "VELOCITY_CONNECT"
      target: "smp"

  SV2:
    enabled: true
    display-name: "SV2"
    velocity-server: "helden"
    status:
      online-text: "Online"
      offline-text: "Offline"
    button:
      material: "DIAMOND_BLOCK"
      slot: 12
      background-color: "#FFFFFF"
    action:
      type: "VELOCITY_CONNECT"
      target: "helden"
```

Erweitere die Config entsprechend für SV3 bis SV6.

Die Statusanzeige darf nicht nur einen frei eingetragenen Text anzeigen. Sie soll möglichst den tatsächlichen Verbindungsstatus des jeweiligen Velocity-Backends prüfen. Falls ein Server nicht erreichbar ist, muss er als Offline markiert werden.

## 7. Verbindung zu Velocity

Das Plugin läuft auf einem Paper-Backend hinter einem Velocity-Proxy.

Beim Anklicken eines Serverbuttons soll der Spieler über Velocity zum konfigurierten Zielserver weitergeleitet werden.

Beispiel:

- SV1 → `smp`
- SV2 → `helden`
- SV3 → konfigurierbarer Zielserver
- SV4 → konfigurierbarer Zielserver
- SV5 → konfigurierbarer Zielserver
- SV6 → konfigurierbarer Zielserver

Verwende für Paper eine passende, sichere Lösung, beispielsweise den BungeeCord-Plugin-Messaging-Kanal `Connect`, sofern dieser korrekt über Velocity unterstützt wird. Alternativ kann ein geeigneter Proxy-Integrationsmechanismus verwendet werden.

Wichtig:

- Das Plugin darf nicht so tun, als könnte ein Paper-Backend direkt einen beliebigen `/server`-Befehl auf Velocity ausführen.
- Der Wechsel muss tatsächlich über den Proxy erfolgen.
- Wenn das Ziel offline ist, darf der Spieler nicht fälschlicherweise eine Erfolgsmeldung erhalten.
- Stelle sicher, dass der Befehl nicht versehentlich auf dem Backend statt auf dem Proxy ausgeführt wird.

## 8. Konfigurierbare Chatnachrichten

Erstelle einen vollständig konfigurierbaren Nachrichtenbereich in `config.yml`.

Unterstütze Hex-Farben und MiniMessage, beispielsweise:

`[MiniCity]`

Beispiel:

```yaml
messages:
  prefix: "[MiniCity]"

  no-permission: "Du hast keine Berechtigung für diesen Befehl."

  player-only: "Dieser Befehl kann nur von Spielern verwendet werden."

  items-given: "Du hast die vier MiniCity-Blöcke erhalten!"

  server-online: "Der Server ist online. Du wirst verbunden..."

  server-offline: "Dieser Server ist momentan offline."

  connection-failed: "Die Verbindung konnte nicht hergestellt werden."

  invalid-server: "Dieser Server ist nicht konfiguriert."

  menu-opened: "Serverauswahl geöffnet."
```

Alle Nachrichten müssen vollständig in der Config bearbeitbar sein.

## 9. Sicherheit und Stabilität

- Sichere alle GUI-Events gegen Item-Duplizierung.
- Verhindere das Verschieben, Ablegen und Herausnehmen von GUI-Items.
- Verhindere unerlaubte Verwendung der Custom-Blöcke.
- Erkenne Custom-Blöcke über eindeutige PersistentDataContainer-Tags.
- Vermeide unnötige Aufgaben im Hauptthread.
- Prüfe Eingaben bei `/code`.
- Prüfe, ob Zielserver existieren.
- Behandle Verbindungsfehler sauber.
- Unterstütze Reload der Konfiguration über einen Admin-Command, ohne den Server neu starten zu müssen, soweit sicher möglich.

## 10. Zusätzliche Commands

Implementiere:

- `/code 2309 80 4` – gibt die vier MiniCity-Blöcke.
- `/minicity` – öffnet das Serverauswahl-Menü.
- `/minicity reload` – lädt die Konfiguration neu.
- `/minicity give ` – gibt einem Spieler die vier Blöcke, falls er die nötige Permission besitzt.

Permissions:

- `minicity.use`
- `minicity.give`
- `minicity.reload`

## 11. Resourcepack und Custom-Modelle

Wenn echte Custom-Texturen und 3D-Modelle benötigt werden, erstelle alle notwendigen Resourcepack-Dateien.

Liefere, soweit möglich:

- JSON-Modell-Dateien
- Texturen
- Item-Modelle
- Resourcepack-Ordnerstruktur
- passende CustomModelData- oder Item-Model-Definitionen für die unterstützte Minecraft-Version
- eine `pack.mcmeta`
- eine Erklärung, wie das Resourcepack verteilt wird

Erfinde keine nicht existierenden Minecraft-APIs oder Materialnamen. Verwende nur APIs und Ressourcenformate, die mit der Zielversion kompatibel sind.

## 12. Gewünschte Ausgabe

Liefere das komplette Projekt, nicht nur Beispielcode.

Die Ausgabe soll enthalten:

1. Vollständige Projektstruktur.
2. Sämtliche Java-Dateien.
3. `plugin.yml`.
4. Vollständige `config.yml` mit allen sechs Servern.
5. Vollständige Resourcepack-Dateien, soweit für die Umsetzung erforderlich.
6. `pom.xml` oder `build.gradle`.
7. Kompilierungsanleitung.
8. Installationsanleitung für Paper 1.21.11.
9. Anleitung für die Einrichtung mit Velocity.
10. Anleitung zum Testen der sechs Serverbuttons.
11. Eine ehrliche Erklärung aller Einschränkungen, insbesondere bei Custom-Blöcken, Texturen, Miniaturstadt und tatsächlicher Statusprüfung.

Schreibe den Code vollständig und konsistent. Keine Platzhalter wie „hier den Rest ergänzen“, keine ausgelassenen Klassen und keine erfundenen APIs. Wenn eine Funktion technisch nicht direkt mit der Paper-API möglich ist, implementiere die bestmögliche kompatible Alternative und erkläre sie ausdrücklich.
Kodari AI
KodariOct 19 at 6:23 pm 1
MiniCityServerSelector
A Paper 1.21 plugin providing a Velocity proxy server selector with an interactive miniature city. Players receive four custom blocks with unique PersistentDataContainer tags that form a connected city model when placed. Interacting with the city opens a scrollable, searchable server selection GUI with six configurable server buttons, each showing real online/offline status via BungeeCord messaging channel. The plugin includes configurable commands, messages with MiniMessage support, permissions, sounds, particle effects, and a complete resourcepack with custom model data and textures for the four city blocks.

[Generation stopped]

Mr UltraHD

beil dich und mach es supper krass eien kleone cutom block stadt halt ne beil dich

Kodari AI
KodariOct 19 at 6:33 pm 1
  1. Ich erstelle Plugin-Grundgerüst, Config und Commands.

  2. Vier markierte, platzierbare Stadtteile werden gespeichert; Teil 4 öffnet das Menü.

  3. Das Menü bekommt sechs Server, Statusprüfung und Velocity-Weiterleitung; echte Modelle kommen anschließend aus Kodari Studio.

Projekt angelegt: /code 2309 80 4 gibt vier markierte Stadtteile aus; /minicity öffnet das geschützte, seitenweise Servermenü; /minicity reload und /minicity give <spieler> sind ebenfalls enthalten. Die Serverliste, Texte, Materialien und Slots stehen in config.yml.

Wichtig: Die Teile sehen derzeit wie konfigurierbare Vanilla-Blöcke aus. CustomModelData allein erzeugt keine eigenen Modelle oder Texturen. Erstelle die Miniaturstadt und ihre Modelle in Kodari Studio und bring sie anschließend über einen Workspace in dieses Projekt. Texture-Generierung ist momentan deaktiviert: aktiviere sie unter Generation in den Projekteinstellungen oder auf https://kodari.ai/settings?tab=features.

Die Statusprüfung prüft, ob der konfigurierte Server-Port per TCP erreichbar ist; sie bestätigt nicht den Minecraft-Status. Velocity-Weiterleitungen verwenden den BungeeCord-Kanal. Aktiviere dafür in velocity.toml bungee-plugin-message-channel = true und passe die Beispieladressen, Ports und Proxy-Zielnamen in config.yml an.

Zum Kompilieren: Compile in der oberen Leiste (mobil: ⋮ → Compile Project), danach im Fenster Compile und anschließend Download wählen.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
settings.gradle
Code
9 898
src/main/java/com/kodari/minicity/MiniCityServerSelector.java
package com.kodari.minicity;

import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitTask;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public final class MiniCityServerSelector extends JavaPlugin {
    private final Map<String, StatusTarget> statusTargets = new LinkedHashMap<>();
    private final Map<String, Boolean> serverStatus = new ConcurrentHashMap<>();
    private final Map<String, Long> lastStatusCheck = new ConcurrentHashMap<>();
    private CityBlockManager cityBlockManager;
    private ServerMenu serverMenu;
    private BukkitTask statusTask;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        cityBlockManager = new CityBlockManager(this);
        serverMenu = new ServerMenu(this);

        getServer().getMessenger().registerOutgoingPluginChannel(this, "BungeeCord");
        getServer().getPluginManager().registerEvents(new CityListener(this, cityBlockManager, serverMenu), this);
        getServer().getPluginManager().registerEvents(serverMenu, this);

        MiniCityCommand command = new MiniCityCommand(this);
        getCommand("code").setExecutor(command);
        getCommand("code").setTabCompleter(command);
        getCommand("minicity").setExecutor(command);
        getCommand("minicity").setTabCompleter(command);
        restartStatusChecks();
    }

    @Override
    public void onDisable() {
        if (statusTask != null) {
            statusTask.cancel();
        }
        if (cityBlockManager != null) {
            cityBlockManager.save();
        }
    }

    public CityBlockManager cityBlocks() {
        return cityBlockManager;
    }

    public ServerMenu serverMenu() {
        return serverMenu;
    }

    public boolean isServerOnline(String id) {
        return serverStatus.getOrDefault(id, false);
    }

    public void message(CommandSender sender, String key) {
        String prefix = getConfig().getString("messages.prefix", "");
        String text = getConfig().getString("messages." + key, "");
        sender.sendMessage(MiniMessage.miniMessage().deserialize(prefix + text));
    }

    public void reloadSettings() {
        reloadConfig();
        restartStatusChecks();
    }

    public void connectToServer(Player player, String id) {
        ConfigurationSection server = getConfig().getConfigurationSection("servers." + id);
        if (server == null || !server.getBoolean("enabled", false)) {
            message(player, "invalid-server");
            return;
        }
        if (!isServerOnline(id)) {
            message(player, "server-offline");
            return;
        }
        if (!"VELOCITY_CONNECT".equalsIgnoreCase(server.getString("action.type", ""))) {
            message(player, "connection-failed");
            return;
        }

        String target = server.getString("action.target", "").trim();
        if (target.isEmpty()) {
            message(player, "connection-failed");
            return;
        }
        try (ByteArrayOutputStream bytes = new ByteArrayOutputStream();
             DataOutputStream output = new DataOutputStream(bytes)) {
            output.writeUTF("Connect");
            output.writeUTF(target);
            player.sendPluginMessage(this, "BungeeCord", bytes.toByteArray());
            message(player, "server-online");
        } catch (IOException exception) {
            getLogger().warning("Could not send Velocity transfer request for " + id + ": " + exception.getMessage());
            message(player, "connection-failed");
        }
    }

    private void restartStatusChecks() {
        if (statusTask != null) {
            statusTask.cancel();
        }
        statusTargets.clear();
        lastStatusCheck.clear();
        serverStatus.clear();

        ConfigurationSection servers = getConfig().getConfigurationSection("servers");
        if (servers == null) {
            return;
        }
        for (String id : servers.getKeys(false)) {
            ConfigurationSection server = servers.getConfigurationSection(id);
            if (server == null || !server.getBoolean("enabled", true)) {
                continue;
            }
            ConfigurationSection check = server.getConfigurationSection("status-check");
            boolean checkEnabled = check != null && check.getBoolean("enabled", false);
            boolean defaultOnline = server.getBoolean("status.default-online", false);
            if (checkEnabled) {
                statusTargets.put(id, new StatusTarget(
                        check.getString("host", "127.0.0.1"),
                        check.getInt("port", 25565),
                        Math.max(5, check.getInt("interval-seconds", 10))));
                serverStatus.put(id, false);
            } else {
                serverStatus.put(id, defaultOnline);
            }
        }

        if (statusTargets.isEmpty()) {
            return;
        }
        Map<String, StatusTarget> targets = Map.copyOf(statusTargets);
        statusTask = getServer().getScheduler().runTaskTimerAsynchronously(this, () -> {
            long now = System.currentTimeMillis();
            targets.forEach((id, target) -> {
                long last = lastStatusCheck.getOrDefault(id, 0L);
                if (now - last < target.intervalSeconds() * 1000L) {
                    return;
                }
                lastStatusCheck.put(id, now);
                boolean online = false;
                try (Socket socket = new Socket()) {
                    socket.connect(new InetSocketAddress(target.host(), target.port()), 1200);
                    online = true;
                } catch (IOException ignored) {
                }
                serverStatus.put(id, online);
            });
        }, 20L, 20L);
    }

    private record StatusTarget(String host, int port, int intervalSeconds) {
    }
}