City Generator Plugin

Um ein eigenes Minecraft-Server-Plugin zu erstellen, das mithilfe der Bukkit API eine ganze Stadt generiert, benötigt man eine Entwicklungsumgebung, Grundkenntnisse in Java-Programmierung und die Spigot-API. In dieser Anleitung werde ich aufzeigen, wie man ein eigenes Minecraft-Plugin entwickelt, dass auf einem Befehl hin eine Stadt generiert, die aus mehreren Strukturen wie Häusern, Straßen und einem zentralen Platz besteht.

Tristania Citty

Voraussetzungen

  1. Java Development Kit (JDK): Installiere die neueste Version von JDK.
  2. Entwicklungsumgebung (IDE): Nutze eine IDE wie IntelliJ IDEA oder Eclipse.
  3. Spigot Server: Richte einen Spigot-Server ein, auf dem du dein Plugin testen kannst. Lade den Spigot-Server hier herunter.

1. Projekt einrichten

Schritt 1: Neues Maven-Projekt erstellen

  1. Öffne deine IDE und erstelle ein neues Maven-Projekt.
  2. Gib deinem Projekt einen Namen, z.B. CityGenerator.
  3. Füge in der pom.xml die Abhängigkeit zur Spigot-API hinzu:
    <dependencies>
        <dependency>
            <groupId>org.spigotmc</groupId>
            <artifactId>spigot-api</artifactId>
            <version>1.20.1-R0.1-SNAPSHOT</version> <!-- Die Version entsprechend deiner Spigot-Version anpassen -->
            <scope>provided</scope>
        </dependency>
    </dependencies>

2. Plugin-Setup

Schritt 2: Hauptklasse erstellen

  1. Erstelle eine neue Java-Klasse im src/main/java-Verzeichnis, z.B. Main.java:
    package com.example.citygenerator;
    import org.bukkit.plugin.java.JavaPlugin;
    public class Main extends JavaPlugin {
        @Override
        public void onEnable() {
            getLogger().info("CityGenerator Plugin aktiviert!");
            this.getCommand("generatecity").setExecutor(new CityCommand());
        }
        @Override
        public void onDisable() {
            getLogger().info("CityGenerator Plugin deaktiviert!");
        }
    }
    • Die Klasse Main erweitert JavaPlugin und registriert den Befehl generatecity.

Schritt 3: Befehlsklasse erstellen

  1. Erstelle eine neue Klasse namens CityCommand.java:
    package com.example.citygenerator;
    import org.bukkit.Material;
    import org.bukkit.World;
    import org.bukkit.command.Command;
    import org.bukkit.command.CommandExecutor;
    import org.bukkit.command.CommandSender;
    import org.bukkit.entity.Player;
    import org.bukkit.Location;
    public class CityCommand implements CommandExecutor {
        @Override
        public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
            if (sender instanceof Player) {
                Player player = (Player) sender;
                World world = player.getWorld();
                Location location = player.getLocation();
                generateCity(world, location);
                player.sendMessage("Eine Stadt wurde vor dir generiert!");
                return true;
            }
            return false;
        }
        // Methode zur Generierung einer Stadt
        private void generateCity(World world, Location location) {
            // Definiere die Stadtgröße
            int cityWidth = 50;
            int cityLength = 50;
            int streetWidth = 3;
            // Erstelle Straßen
            generateStreets(world, location, cityWidth, cityLength, streetWidth);
            // Erstelle Häuser entlang der Straßen
            generateHouses(world, location, cityWidth, cityLength, streetWidth);
            // Erstelle einen zentralen Platz
            generateCentralSquare(world, location, cityWidth, cityLength);
        }
        private void generateStreets(World world, Location location, int width, int length, int streetWidth) {
            int baseX = location.getBlockX();
            int baseY = location.getBlockY();
            int baseZ = location.getBlockZ();
            for (int x = baseX; x < baseX + width; x++) {
                for (int z = baseZ; z < baseZ + length; z++) {
                    if (x % 10 < streetWidth || z % 10 < streetWidth) {
                        for (int y = baseY; y < baseY + 1; y++) {
                            world.getBlockAt(x, y, z).setType(Material.STONE);
                        }
                    }
                }
            }
        }
        private void generateHouses(World world, Location location, int width, int length, int streetWidth) {
            int baseX = location.getBlockX();
            int baseY = location.getBlockY();
            int baseZ = location.getBlockZ();
            for (int x = baseX; x < baseX + width; x += 10) {
                for (int z = baseZ; z < baseZ + length; z += 10) {
                    if (x % 10 >= streetWidth && z % 10 >= streetWidth) {
                        generateHouse(world, new Location(world, x, baseY, z));
                    }
                }
            }
        }
        private void generateHouse(World world, Location location) {
            int baseX = location.getBlockX();
            int baseY = location.getBlockY();
            int baseZ = location.getBlockZ();
            // Erstelle einfache Wände und ein Dach
            for (int x = baseX; x < baseX + 5; x++) {
                for (int z = baseZ; z < baseZ + 5; z++) {
                    for (int y = baseY; y < baseY + 4; y++) {
                        if (x == baseX || x == baseX + 4 || z == baseZ || z == baseZ + 4) {
                            world.getBlockAt(x, y, z).setType(Material.COBBLESTONE);
                        } else if (y == baseY + 4) {
                            world.getBlockAt(x, y, z).setType(Material.OAK_PLANKS);
                        }
                    }
                }
            }
            // Erstelle eine Tür
            world.getBlockAt(baseX + 2, baseY + 1, baseZ).setType(Material.OAK_DOOR);
        }
        private void generateCentralSquare(World world, Location location, int width, int length) {
            int centerX = location.getBlockX() + width / 2;
            int centerZ = location.getBlockZ() + length / 2;
            int baseY = location.getBlockY();
            // Erstelle einen quadratischen Platz
            for (int x = centerX - 5; x < centerX + 5; x++) {
                for (int z = centerZ - 5; z < centerZ + 5; z++) {
                    world.getBlockAt(x, baseY, z).setType(Material.STONE_BRICKS);
                }
            }
        }
    }
    • Die CityCommand-Klasse implementiert CommandExecutor, um den Befehl /generatecity zu verarbeiten.
    • Die Methoden generateStreets, generateHouses, und generateCentralSquare erstellen Straßen, Häuser und einen zentralen Platz.

Schritt 4: Die plugin.yml-Datei erstellen

  1. Erstelle eine Datei namens plugin.yml im Verzeichnis src/main/resources:
    name: CityGenerator
    version: 1.0
    main: com.example.citygenerator.Main
    api-version: 1.20
    commands:
      generatecity:
        description: Generiert eine Stadt an der aktuellen Position des Spielers.
        usage: /generatecity
    • Die Datei plugin.yml enthält die Basisinformationen und registriert den Befehl generatecity.

3. Plugin kompilieren und testen

  1. Kompiliere das Plugin mit deiner IDE oder Maven (mvn package). Die kompilierte .jar-Datei wird im target-Verzeichnis gespeichert.
  2. Kopiere die .jar-Datei in den plugins-Ordner deines Spigot-Servers.
  3. Starte den Server oder lade das Plugin neu mit dem Befehl /reload.
  4. Teste das Plugin, indem du den Befehl /generatecity im Spiel eingibst. Eine einfache Stadt sollte an deiner Position erscheinen.

4. Erweiterungen und Anpassungen

  • Weitere Strukturen hinzufügen: Baue weitere Gebäudetypen wie Türme, Brücken oder Parks.
  • Straßenlayout variieren: Ändere das Muster und die Breite der Straßen.
  • Anpassbare Materialien: Füge eine Möglichkeit hinzu, Materialien für die Stadt zu ändern.
  • Zufällige Stadtgenerierung: Erstelle zufällige Variationen, um die Stadt einzigartiger zu gestalten.

Fazit

Mit dieser Anleitung hast du gelernt, ein Minecraft-Plugin zu erstellen, das eine Stadt generiert. Mit der Bukkit API kannst du die Welt nach deinen Wünschen gestalten und coole Projekte entwickeln. Experimentiere mit verschiedenen Ideen und erweitere dein Plugin, um deine Minecraft-Welt noch spannender zu machen!