README.md aktualisiert

Update from Git Manager GUI
Upload pom.xml via GUI
2026-01-23 11:40:28 +00:00 · 2026-01-23 12:17:49 +01:00 · 2026-01-23 11:17:49 +00:00 · 2026-01-23 09:43:54 +00:00 · 2026-01-23 10:43:53 +01:00 · 2026-01-22 23:16:25 +01:00
25 changed files with 2221 additions and 174 deletions
--- a/README.md
+++ b/README.md
@@ -18,11 +18,11 @@ Ein umfassendes Lobby-Plugin fur Minecraft Server (Paper/Spigot 1.21+) mit modul

 Dieses Plugin ist urheberrechtlich geschutzt. Es gelten folgende Bedingungen:

- Die Nutzung ist ausschliesslich fur den personlichen Gebrauch gestattet
- Die Weitergabe, Verbreitung oder Veroffentlichung des Plugins ist **strengstens untersagt**
+- Die Nutzung ist ausschliesslich fur den persönlichen Gebrauch gestattet
+- Die Weitergabe, Verbreitung oder Veröffentlichung des Plugins ist **strengstens untersagt**
 - Jegliche Anderung, Modifikation oder Dekompilierung des Codes ist **verboten**
 - Das Plugin darf nicht verkauft, vermietet oder anderweitig kommerziell genutzt werden
- Eine Weitergabe an Dritte ist ohne ausdruckliche schriftliche Genehmigung nicht gestattet
+- Eine Weitergabe an Dritte ist ohne ausdrückliche schriftliche Genehmigung nicht gestattet

 Bei Verstoss gegen diese Bedingungen behalten wir uns rechtliche Schritte vor.

@@ -45,27 +45,27 @@ Bei Verstoss gegen diese Bedingungen behalten wir uns rechtliche Schritte vor.
 ### Sicherheit
 - **VPN-Blocker** - Blockiert VPN/Proxy-Verbindungen (proxycheck.io API)
 - **Country-Blocker** - Erlaubt nur bestimmte Lander (Whitelist/Blacklist)
- **Wartungsmodus** - Sperrt den Server fur nicht-berechtigte Spieler
- **Lobby-Schutz** - Verhindert Griefing und unerwunschte Aktionen
+- **Wartungsmodus** - Sperrt den Server für nicht-berechtigte Spieler
+- **Lobby-Schutz** - Verhindert Griefing und unerwünschte Aktionen

 ### Zusatzliche Module
 - **Portal-System** - Erstelle Portale fur Server-Wechsel (BungeeCord)
 - **ArmorStand-Tools** - Bearbeite ArmorStands mit GUI und Command-Binding
 - **Server-Switcher** - GUI-basierter Server-Wechsel
 - **Spieler verstecken** - Toggle fur Spieler-Sichtbarkeit
- **Chat-Suppressor** - Unterdruckung fur globalen Chat
+- **Chat-Suppressor** - Unterdrückung fur globalen Chat

 ---

 ## Installation

 ### Voraussetzungen
- Paper/Spigot Server 1.21 oder hoher
+- Paper/Spigot Server 1.21 oder höher
 - Java 21 oder hoher

 ### Optionale Abhangigkeiten
- [PlaceholderAPI](https://www.spigotmc.org/resources/placeholderapi.6245/) - Fur Platzhalter-Support
- [LuckPerms](https://luckperms.net/) - Fur Berechtigungsverwaltung
+- [PlaceholderAPI](https://www.spigotmc.org/resources/placeholderapi.6245/) - Für Platzhalter-Support
+- [LuckPerms](https://luckperms.net/) - Für Berechtigungsverwaltung

 ### Schritte
 1. Lade `NexusLobby.jar` herunter
@@ -195,6 +195,6 @@ Das Plugin registriert eigene Platzhalter unter der Expansion `nexuslobby`:

 ---

-**Copyright (c) 2024 - Alle Rechte vorbehalten**
+**Copyright (c) 2025 - Alle Rechte vorbehalten**

-Die unbefugte Vervielfaltigung, Verbreitung oder Weitergabe dieses Plugins ist strafbar und wird rechtlich verfolgt.
+Die unbefugte Vervielfältigung, Verbreitung oder Weitergabe dieses Plugins ist strafbar und wird rechtlich verfolgt.
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@

    <groupId>de.nexuslobby</groupId>
    <artifactId>NexusLobby</artifactId>
-    <version>1.0.1</version>
+    <version>1.0.4</version>
    <packaging>jar</packaging>

    <name>NexusLobby</name>
--- a/src/main/java/de/nexuslobby/NexusLobby.java
+++ b/src/main/java/de/nexuslobby/NexusLobby.java
@@ -14,12 +14,11 @@ import de.nexuslobby.modules.portal.PortalManager;
 import de.nexuslobby.modules.portal.PortalCommand;
 import de.nexuslobby.modules.servers.ServerSwitcherListener;
 import de.nexuslobby.modules.armorstandtools.*; 
-import de.nexuslobby.utils.VoidProtection;
-import de.nexuslobby.utils.DoubleJump;
-import de.nexuslobby.utils.PlayerHider;
-import de.nexuslobby.utils.MaintenanceListener;
-import de.nexuslobby.utils.ConfigUpdater;
-import de.nexuslobby.utils.UpdateChecker;
+import de.nexuslobby.modules.gadgets.GadgetModule;
+import de.nexuslobby.modules.hologram.HologramModule;
+import de.nexuslobby.modules.mapart.MapArtModule; // Neu
+import de.nexuslobby.modules.intro.IntroModule; // Neu
+import de.nexuslobby.utils.*;
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
 import net.md_5.bungee.api.chat.ClickEvent;
 import net.md_5.bungee.api.chat.ComponentBuilder;
@@ -47,6 +46,12 @@ public class NexusLobby extends JavaPlugin implements Listener {
    private PortalManager portalManager;
    private TablistModule tablistModule;
    private LobbySettingsModule lobbySettingsModule;
+    private ItemsModule itemsModule;
+    private GadgetModule gadgetModule;
+    private HologramModule hologramModule;
+    private DynamicArmorStandModule dynamicArmorStandModule;
+    private MapArtModule mapArtModule; // Neu
+    private IntroModule introModule; // Neu

    private File visualsFile;
    private FileConfiguration visualsConfig;
@@ -126,7 +131,27 @@ public class NexusLobby extends JavaPlugin implements Listener {
    private void registerModules() {
        moduleManager.registerModule(new ProtectionModule());
        moduleManager.registerModule(new ScoreboardModule());
-        moduleManager.registerModule(new ItemsModule());
+        
+        this.itemsModule = new ItemsModule();
+        moduleManager.registerModule(this.itemsModule);
+
+        this.gadgetModule = new GadgetModule();
+        moduleManager.registerModule(this.gadgetModule);
+
+        this.hologramModule = new HologramModule();
+        moduleManager.registerModule(this.hologramModule);
+
+        // Dynamic ArmorStand Module
+        this.dynamicArmorStandModule = new DynamicArmorStandModule();
+        moduleManager.registerModule(this.dynamicArmorStandModule);
+
+        // MapArt & Intro Module
+        this.mapArtModule = new MapArtModule();
+        moduleManager.registerModule(this.mapArtModule);
+        
+        this.introModule = new IntroModule();
+        moduleManager.registerModule(this.introModule);
+
        moduleManager.registerModule(new SecurityModule()); 
        moduleManager.registerModule(new BossBarModule());
        moduleManager.registerModule(new ActionBarModule());
@@ -151,15 +176,13 @@ public class NexusLobby extends JavaPlugin implements Listener {
        getServer().getPluginManager().registerEvents(new ASTListener(), this);
    }

-    // Priorität auf LOWEST, damit das Inventar VOR den Modulen geleert wird
    @EventHandler(priority = EventPriority.LOWEST)
    public void onJoin(PlayerJoinEvent event) {
        Player player = event.getPlayer();
        event.setJoinMessage(null); 

-        // FEHLERBEHEBUNG: Inventar leeren, um doppelte Items zu vermeiden
        player.getInventory().clear();
-        player.getInventory().setArmorContents(null); // Auch Rüstung entfernen
+        player.getInventory().setArmorContents(null); 

        BuildCommand.removePlayerFromBuildMode(player);

@@ -194,7 +217,7 @@ public class NexusLobby extends JavaPlugin implements Listener {
        if (!configFile.exists()) {
            saveResource("config.yml", false);
        }
-        ConfigUpdater.updateConfig("config.yml");
+        
        reloadConfig();

        File settingsFile = new File(getDataFolder(), "settings.yml");
@@ -234,7 +257,7 @@ public class NexusLobby extends JavaPlugin implements Listener {
    }

    private void registerCommands() {
-        LobbyTabCompleter tabCompleter = new LobbyTabCompleter(portalManager);
+        LobbyTabCompleter tabCompleter = new LobbyTabCompleter(portalManager, hologramModule);

        PluginCommand portalCmd = this.getCommand("portal");
        if (portalCmd != null) {
@@ -242,6 +265,12 @@ public class NexusLobby extends JavaPlugin implements Listener {
            portalCmd.setTabCompleter(tabCompleter);
        }

+        PluginCommand holoCmd = this.getCommand("holo");
+        if (holoCmd != null) {
+            holoCmd.setExecutor(new HoloCommand(hologramModule));
+            holoCmd.setTabCompleter(tabCompleter);
+        }
+
        PluginCommand maintenanceCmd = this.getCommand("maintenance");
        if (maintenanceCmd != null) {
            maintenanceCmd.setExecutor(new MaintenanceCommand());
@@ -267,6 +296,10 @@ public class NexusLobby extends JavaPlugin implements Listener {
            nexusCmd.setExecutor(new NexusLobbyCommand());
            nexusCmd.setTabCompleter(tabCompleter);
        }
+
+        // Neue Commands im TabCompleter registrieren
+        if (getCommand("mapart") != null) getCommand("mapart").setTabCompleter(tabCompleter);
+        if (getCommand("introtest") != null) getCommand("introtest").setTabCompleter(tabCompleter);
    }

    public class NexusLobbyExpansion extends PlaceholderExpansion {
@@ -288,4 +321,8 @@ public class NexusLobby extends JavaPlugin implements Listener {
    public ModuleManager getModuleManager() { return moduleManager; }
    public TablistModule getTablistModule() { return tablistModule; }
    public LobbySettingsModule getLobbySettingsModule() { return lobbySettingsModule; }
+    public ItemsModule getItemsModule() { return itemsModule; }
+    public GadgetModule getGadgetModule() { return gadgetModule; }
+    public HologramModule getHologramModule() { return hologramModule; }
+    public DynamicArmorStandModule getDynamicArmorStandModule() { return dynamicArmorStandModule; }
 }
--- a/src/main/java/de/nexuslobby/commands/BuildCommand.java
+++ b/src/main/java/de/nexuslobby/commands/BuildCommand.java
@@ -12,7 +12,6 @@ import java.util.UUID;

 public class BuildCommand implements CommandExecutor {

-    // Liste der Spieler im Baumodus
    private static final ArrayList<UUID> buildModePlayers = new ArrayList<>();

    @Override
@@ -30,7 +29,16 @@ public class BuildCommand implements CommandExecutor {
            // BAUMODUS DEAKTIVIEREN
            buildModePlayers.remove(uuid);
            
-            // Gamemode zurücksetzen (aus Config)
+            // Inventar leeren
+            player.getInventory().clear();
+            player.getInventory().setArmorContents(null);
+
+            // Lobby-Items über das Modul wiedergeben
+            if (NexusLobby.getInstance().getItemsModule() != null) {
+                NexusLobby.getInstance().getItemsModule().giveLobbyItems(player);
+            }
+            
+            // Gamemode zurücksetzen
            String defaultGmName = NexusLobby.getInstance().getConfig().getString("default-gamemode", "ADVENTURE");
            try {
                GameMode gm = GameMode.valueOf(defaultGmName.toUpperCase());
@@ -43,6 +51,9 @@ public class BuildCommand implements CommandExecutor {
        } else {
            // BAUMODUS AKTIVIEREN
            buildModePlayers.add(uuid);
+            
+            player.getInventory().clear();
+            player.getInventory().setArmorContents(null);
            player.setGameMode(GameMode.CREATIVE);
            
            player.sendMessage("§8» §6§lBuild §8| §7Baumodus §aaktiviert§7.");
--- a/src/main/java/de/nexuslobby/commands/LobbyTabCompleter.java
+++ b/src/main/java/de/nexuslobby/commands/LobbyTabCompleter.java
@@ -1,9 +1,11 @@
 package de.nexuslobby.commands;

 import de.nexuslobby.modules.portal.PortalManager;
+import de.nexuslobby.modules.hologram.HologramModule;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;

 import java.util.ArrayList;
 import java.util.Arrays;
@@ -13,13 +15,15 @@ import java.util.stream.Collectors;
 public class LobbyTabCompleter implements TabCompleter {

    private final PortalManager portalManager;
+    private final HologramModule hologramModule;

-    public LobbyTabCompleter(PortalManager portalManager) {
+    public LobbyTabCompleter(PortalManager portalManager, HologramModule hologramModule) {
        this.portalManager = portalManager;
+        this.hologramModule = hologramModule;
    }

    @Override
-    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
+    public List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, String[] args) {
        List<String> suggestions = new ArrayList<>();

        // --- NexusLobby Hauptbefehl ---
@@ -35,6 +39,16 @@ public class LobbyTabCompleter implements TabCompleter {
                    suggestions.add("spieler");
                }
            }
+        } 
+        
+        // --- Hologram Befehl ---
+        else if (command.getName().equalsIgnoreCase("holo")) {
+            if (args.length == 1) {
+                suggestions.add("create");
+                suggestions.add("delete");
+            } else if (args.length == 2 && args[0].equalsIgnoreCase("delete")) {
+                suggestions.addAll(hologramModule.getHologramIds());
+            }
        }
        
        // --- Wartungsmodus ---
@@ -56,44 +70,55 @@ public class LobbyTabCompleter implements TabCompleter {
            }
        }
        
-        // --- NexusTools (ehemals astools) ---
-        else if (command.getName().equalsIgnoreCase("nexustools") || command.getName().equalsIgnoreCase("astools") || command.getName().equalsIgnoreCase("nt")) {
+        // --- MapArt ---
+        else if (command.getName().equalsIgnoreCase("mapart")) {
            if (args.length == 1) {
-                suggestions.add("reload");
+                suggestions.add("https://");
+            } else if (args.length == 2) {
+                suggestions.add("1x1");
+                suggestions.add("3x2");
+                suggestions.add("6x4");
+            }
+        }
+
+        // --- Intro System ---
+        else if (command.getName().equalsIgnoreCase("intro")) {
+            if (args.length == 1) {
+                suggestions.add("add");
+                suggestions.add("clear");
+                suggestions.add("start");
            }
        }
        
-        // --- NexusCmd (ehemals ascmd) ---
+        // --- NexusTools ---
+        else if (command.getName().equalsIgnoreCase("nexustools") || command.getName().equalsIgnoreCase("astools") || command.getName().equalsIgnoreCase("nt")) {
+            if (args.length == 1) {
+                suggestions.add("reload");
+                suggestions.add("dynamic"); 
+            }
+        }
+        
+        // --- NexusCmd ---
        else if (command.getName().equalsIgnoreCase("nexuscmd") || command.getName().equalsIgnoreCase("ascmd") || command.getName().equalsIgnoreCase("ncmd")) {
            if (args.length == 1) {
-                suggestions.add("name"); // NEU
+                suggestions.add("name");
                suggestions.add("list");
                suggestions.add("add");
                suggestions.add("remove");
            } 
-            // Vorschläge für: /nexuscmd name <Text>
            else if (args.length == 2 && args[0].equalsIgnoreCase("name")) {
                suggestions.add("none");
-                suggestions.add("<Text>");
            }
-            // Vorschläge für: /nexuscmd add <delay> <cooldown> <type>
            else if (args.length == 2 && args[0].equalsIgnoreCase("add")) {
                suggestions.add("0"); 
            } 
-            else if (args.length == 3 && args[0].equalsIgnoreCase("add")) {
-                suggestions.add("0"); 
-            } 
            else if (args.length == 4 && args[0].equalsIgnoreCase("add")) {
                suggestions.add("player");
                suggestions.add("console");
                suggestions.add("bungee");
            }
-            else if (args.length == 5 && args[0].equalsIgnoreCase("add") && args[3].equalsIgnoreCase("bungee")) {
-                suggestions.add("<Servername>");
-            }
        }

-        // Filtert die Liste basierend auf dem, was der Spieler bereits getippt hat
        return suggestions.stream()
                .filter(s -> s.toLowerCase().startsWith(args[args.length - 1].toLowerCase()))
                .collect(Collectors.toList());
--- a/src/main/java/de/nexuslobby/modules/BuildModule.java
+++ b/src/main/java/de/nexuslobby/modules/BuildModule.java
@@ -0,0 +1,47 @@
+package de.nexuslobby.modules;
+
+import de.nexuslobby.NexusLobby;
+import de.nexuslobby.api.Module;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.entity.Player;
+import java.util.ArrayList;
+import java.util.UUID;
+
+public class BuildModule implements Module {
+
+    private final ArrayList<UUID> buildModePlayers = new ArrayList<>();
+
+    @Override
+    public String getName() {
+        return "Build";
+    }
+
+    @Override
+    public void onEnable() {
+        // Falls du hier den Command registrierst, achte darauf, 
+        // dass er nicht doppelt in der NexusLobby.java registriert wird.
+    }
+
+    public void toggleBuildMode(Player player) {
+        if (!player.hasPermission("nexuslobby.build")) return;
+
+        if (buildModePlayers.contains(player.getUniqueId())) {
+            buildModePlayers.remove(player.getUniqueId());
+            player.setGameMode(GameMode.SURVIVAL);
+            player.getInventory().clear();
+            
+            // KORREKTUR: Hier muss getItemsModule() mit "s" stehen!
+            if (NexusLobby.getInstance().getItemsModule() != null) {
+                NexusLobby.getInstance().getItemsModule().giveLobbyItems(player);
+            }
+        } else {
+            buildModePlayers.add(player.getUniqueId());
+            player.setGameMode(GameMode.CREATIVE);
+            player.getInventory().clear();
+        }
+    }
+
+    @Override
+    public void onDisable() {}
+}
--- a/src/main/java/de/nexuslobby/modules/ItemsModule.java
+++ b/src/main/java/de/nexuslobby/modules/ItemsModule.java
@@ -1,12 +1,18 @@
 package de.nexuslobby.modules;

+import de.nexuslobby.NexusLobby;
 import de.nexuslobby.api.Module;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
 import org.bukkit.event.Listener;
 import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;

 public class ItemsModule implements Module, Listener {

@@ -17,14 +23,97 @@ public class ItemsModule implements Module, Listener {

    @Override
    public void onEnable() {
-        Bukkit.getPluginManager().registerEvents(this, Bukkit.getPluginManager().getPlugin("NexusLobby"));
+        Bukkit.getPluginManager().registerEvents(this, NexusLobby.getInstance());
    }

    @EventHandler
    public void onJoin(PlayerJoinEvent event) {
-        event.getPlayer().getInventory().addItem(new ItemStack(Material.COMPASS));
+        Bukkit.getScheduler().runTaskLater(NexusLobby.getInstance(), () -> {
+            giveLobbyItems(event.getPlayer());
+        }, 2L);
+    }
+
+    @EventHandler
+    public void onInteract(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        ItemStack item = event.getItem();
+
+        if (item == null || item.getType() == Material.AIR) return;
+        if (!item.hasItemMeta() || !item.getItemMeta().hasDisplayName()) return;
+
+        if (event.getAction() == Action.RIGHT_CLICK_AIR || event.getAction() == Action.RIGHT_CLICK_BLOCK) {
+            FileConfiguration config = NexusLobby.getInstance().getConfig();
+            String displayName = item.getItemMeta().getDisplayName();
+
+            // 1. Baumodus Logik
+            String buildName = colorize(config.getString("items.lobby-tools.build-toggle.displayname", "&aBaumodus"));
+            if (displayName.equals(buildName)) {
+                player.performCommand("build");
+                event.setCancelled(true);
+                return;
+            }
+
+            // 2. Gadget GUI Logik
+            String gadgetName = colorize(config.getString("items.lobby-tools.gadget.displayname", "&bGadgets"));
+            if (displayName.equals(gadgetName)) {
+                // Öffnet die GUI aus dem GadgetModule
+                NexusLobby.getInstance().getGadgetModule().openGUI(player);
+                event.setCancelled(true);
+                return;
+            }
+            
+            // 3. Kompass / Teleporter Logik (optional, falls du den Befehl schon hast)
+            String compassName = colorize(config.getString("items.lobby-tools.compass.displayname", "&eTeleporter"));
+            if (displayName.equals(compassName)) {
+                // Hier könnte z.B. player.performCommand("cp"); stehen
+            }
+        }
+    }
+
+    public void giveLobbyItems(Player player) {
+        player.getInventory().clear();
+        FileConfiguration config = NexusLobby.getInstance().getConfig();
+
+        // 1. Kompass (Slot 4)
+        if (config.getBoolean("items.lobby-tools.compass.enabled", true)) {
+            int slot = config.getInt("items.lobby-tools.compass.slot", 4);
+            String name = config.getString("items.lobby-tools.compass.displayname", "&eTeleporter");
+            player.getInventory().setItem(slot, createItem(Material.COMPASS, name));
+        }
+
+        // 2. Baumodus (Slot 0)
+        if (player.isOp() || player.hasPermission("nexuslobby.build")) {
+            if (config.getBoolean("items.lobby-tools.build-toggle.enabled", true)) {
+                int slot = config.getInt("items.lobby-tools.build-toggle.slot", 0);
+                String name = config.getString("items.lobby-tools.build-toggle.displayname", "&aBaumodus");
+                player.getInventory().setItem(slot, createItem(Material.REDSTONE_TORCH, name));
+            }
+        }
+
+        // 3. Gadgets (Slot 8)
+        if (config.getBoolean("items.lobby-tools.gadget.enabled", true)) { // Auf true gesetzt, damit es erscheint
+            int slot = config.getInt("items.lobby-tools.gadget.slot", 8);
+            String name = config.getString("items.lobby-tools.gadget.displayname", "&bGadgets");
+            player.getInventory().setItem(slot, createItem(Material.CHEST, name));
+        }
+
+        player.updateInventory();
+    }
+
+    private ItemStack createItem(Material mat, String name) {
+        ItemStack item = new ItemStack(mat);
+        ItemMeta meta = item.getItemMeta();
+        if (meta != null) {
+            meta.setDisplayName(colorize(name));
+            item.setItemMeta(meta);
+        }
+        return item;
+    }
+
+    private String colorize(String s) {
+        return (s == null) ? "" : s.replace("&", "§");
    }

    @Override
    public void onDisable() {}
-}
+}
--- a/src/main/java/de/nexuslobby/modules/armorstandtools/ArmorStandCommand.java
+++ b/src/main/java/de/nexuslobby/modules/armorstandtools/ArmorStandCommand.java
@@ -1,6 +1,8 @@
 package de.nexuslobby.modules.armorstandtools;

+import de.nexuslobby.NexusLobby;
 import org.bukkit.ChatColor;
+import org.bukkit.Particle;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
@@ -11,85 +13,143 @@ import org.jetbrains.annotations.NotNull;

 import java.util.Set;

+/**
+ * ArmorStandCommand - Vollständige Steuerung für ArmorStands.
+ * Inklusive Dynamic-Modus Erkennung und visueller Rückmeldung.
+ */
 public class ArmorStandCommand implements CommandExecutor {

    @Override
    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
-        if (!(sender instanceof Player p)) return true;
-
-        if (!p.hasPermission("nexuslobby.armorstand.use")) {
-            p.sendMessage(Config.prefix() + ChatColor.RED + Config.generalNoPerm);
+        if (!(sender instanceof Player p)) {
+            sender.sendMessage("Nur Spieler können diesen Befehl ausführen.");
            return true;
        }

-        // Suche ArmorStand im Umkreis von 5 Blöcken
-        ArmorStand target = getNearbyArmorStand(p);
+        // Fester Prefix für maximale Build-Sicherheit
+        String prefix = "§8[§6Nexus§8] ";

-        // Fall 1: Nur /astools -> GUI öffnen
+        if (!p.hasPermission("nexuslobby.armorstand.use")) {
+            p.sendMessage(prefix + ChatColor.RED + "Dazu hast du keine Rechte!");
+            return true;
+        }
+
+        // 1. Suche nach dem ArmorStand (Präzise & Umkreis)
+        ArmorStand target = getBestTargetArmorStand(p);
+
+        // Fall: Nur /astools oder /nt (Ohne Argumente)
        if (args.length == 0) {
            if (target != null) {
                AST.selectedArmorStand.put(p.getUniqueId(), target);
                new ArmorStandGUI(target, p);
+                p.sendMessage(prefix + "§aEditor für ArmorStand geöffnet.");
            } else {
-                p.sendMessage(Config.prefix() + ChatColor.RED + "Kein ArmorStand in der Nähe gefunden!");
+                p.sendMessage(prefix + ChatColor.RED + "Kein ArmorStand in der Nähe gefunden!");
            }
            return true;
        }

-        // Fall 2: Unterbefehle (add, remove, list)
        String sub = args[0].toLowerCase();

+        // Globaler Reload
+        if (sub.equals("reload")) {
+            NexusLobby.getInstance().reloadPlugin();
+            p.sendMessage(prefix + "§aKonfiguration und Module wurden neu geladen.");
+            return true;
+        }
+
+        // Für alle anderen Aktionen ist ein ArmorStand zwingend erforderlich
        if (target == null) {
-            p.sendMessage(Config.prefix() + ChatColor.RED + "Du musst nah an einem ArmorStand stehen!");
+            p.sendMessage(prefix + ChatColor.RED + "Du musst einen ArmorStand anschauen oder direkt davor stehen!");
            return true;
        }

        switch (sub) {
-            case "addplayer": // /astools addplayer <command>
-                if (args.length < 2) return sendHelp(p);
+            case "dynamic":
+                if (!p.hasPermission("nexuslobby.armorstand.dynamic")) {
+                    p.sendMessage(prefix + ChatColor.RED + "Keine Rechte für Dynamic-NPCs!");
+                    return true;
+                }
+
+                if (NexusLobby.getInstance().getDynamicArmorStandModule() != null) {
+                    // Toggle Logik
+                    if (target.getScoreboardTags().contains("as_dynamic")) {
+                        target.removeScoreboardTag("as_dynamic");
+                        p.sendMessage(prefix + "§c§l[-] §7Dynamic-Modus §cdeaktiviert§7.");
+                        p.spawnParticle(Particle.SMOKE, target.getLocation().add(0, 1, 0), 15, 0.3, 0.3, 0.3, 0.05);
+                    } else {
+                        target.addScoreboardTag("as_dynamic");
+                        p.sendMessage(prefix + "§a§l[+] §7Dynamic-Modus §aaktiviert§7 (Wetter/Zeit).");
+                        // Visueller Erfolgseffekt (Grüne Sternchen)
+                        p.spawnParticle(Particle.HAPPY_VILLAGER, target.getLocation().add(0, 1, 0), 25, 0.5, 0.5, 0.5, 0.1);
+                    }
+                    // Internes Update sofort triggern
+                    NexusLobby.getInstance().getDynamicArmorStandModule().toggleDynamicStatus(target);
+                } else {
+                    p.sendMessage(prefix + "§cFehler: Dynamic-Modul ist nicht aktiv!");
+                }
+                break;
+
+            case "addplayer":
+                if (args.length < 2) return sendHelp(p, prefix);
                String pCmd = buildString(args, 1);
                target.addScoreboardTag("ascmd:player:" + pCmd);
-                p.sendMessage(Config.prefix() + "§aBefehl (Player) hinzugefügt: §e" + pCmd);
+                p.sendMessage(prefix + "§aBefehl (Player) gespeichert: §e/" + pCmd);
                break;

-            case "addconsole": // /astools addconsole <command>
-                if (args.length < 2) return sendHelp(p);
+            case "addconsole":
+                if (args.length < 2) return sendHelp(p, prefix);
                String cCmd = buildString(args, 1);
                target.addScoreboardTag("ascmd:console:" + cCmd);
-                p.sendMessage(Config.prefix() + "§aBefehl (Konsole) hinzugefügt: §e" + cCmd);
+                p.sendMessage(prefix + "§aBefehl (Konsole) gespeichert: §e" + cCmd);
                break;

-            case "addbungee": // /astools addbungee <server>
-                if (args.length < 2) return sendHelp(p);
-                String server = args[1];
-                target.addScoreboardTag("ascmd:bungee:" + server);
-                p.sendMessage(Config.prefix() + "§aBefehl (Bungee) hinzugefügt: §eConnect zu " + server);
-                break;
-
-            case "remove": // /astools remove (Löscht alle ascmd Tags)
-                Set<String> tags = target.getScoreboardTags();
-                tags.removeIf(tag -> tag.startsWith("ascmd:"));
-                p.sendMessage(Config.prefix() + "§cAlle Befehle von diesem ArmorStand entfernt.");
-                break;
-
-            case "reload":
-                Config.load();
-                p.sendMessage(Config.prefix() + "§aKonfiguration neu geladen.");
+            case "remove":
+                target.getScoreboardTags().removeIf(tag -> tag.startsWith("ascmd:"));
+                p.sendMessage(prefix + "§cAlle Befehls-Tags wurden entfernt.");
                break;

            default:
-                sendHelp(p);
+                sendHelp(p, prefix);
                break;
        }

        return true;
    }

-    private ArmorStand getNearbyArmorStand(Player p) {
-        for (Entity e : p.getNearbyEntities(5, 5, 5)) {
-            if (e instanceof ArmorStand as) return as;
+    /**
+     * Sucht den am besten passenden ArmorStand.
+     * Priorität 1: Der ArmorStand, den der Spieler direkt ansieht.
+     * Priorität 2: Der absolut nächste ArmorStand im Umkreis.
+     */
+    private ArmorStand getBestTargetArmorStand(Player p) {
+        ArmorStand best = null;
+        double bestDot = 0.95; // Schwellenwert für das "Anschauen"
+
+        for (Entity e : p.getNearbyEntities(8, 8, 8)) {
+            if (e instanceof ArmorStand as) {
+                // Berechne, ob der Spieler in Richtung des ArmorStands schaut
+                double dot = p.getLocation().getDirection().dot(
+                        as.getLocation().toVector().subtract(p.getLocation().toVector()).normalize()
+                );
+                
+                if (dot > bestDot) {
+                    bestDot = dot;
+                    best = as;
+                }
+            }
        }
-        return null;
+
+        // Falls nichts aktiv angeschaut wird, nimm einfach den nächsten im 4-Block-Radius
+        if (best == null) {
+            for (Entity e : p.getNearbyEntities(4, 4, 4)) {
+                if (e instanceof ArmorStand as) {
+                    return as;
+                }
+            }
+        }
+
+        return best;
    }

    private String buildString(String[] args, int start) {
@@ -100,14 +160,16 @@ public class ArmorStandCommand implements CommandExecutor {
        return sb.toString();
    }

-    private boolean sendHelp(Player p) {
-        p.sendMessage("§6§lArmorStandTools Hilfe:");
-        p.sendMessage("§e/astools §7- Öffnet Editor");
-        p.sendMessage("§e/astools addplayer <cmd> §7- Befehl als Spieler ausführen");
-        p.sendMessage("§e/astools addconsole <cmd> §7- Befehl als Konsole ausführen");
-        p.sendMessage("§e/astools addbungee <server> §7- Serverwechsel");
-        p.sendMessage("§e/astools remove §7- Entfernt alle Befehle");
-        p.sendMessage("§e/astools reload §7- Lädt Config neu");
+    private boolean sendHelp(Player p, String prefix) {
+        p.sendMessage(" ");
+        p.sendMessage("§8§m-----------§r " + prefix + "§8§m-----------");
+        p.sendMessage("§e/astools §7- Editor öffnen");
+        p.sendMessage("§b/astools dynamic §7- Wetter/Zeit Logik umschalten");
+        p.sendMessage("§e/astools addplayer <cmd> §7- Befehl als Spieler");
+        p.sendMessage("§e/astools addconsole <cmd> §7- Befehl via Konsole");
+        p.sendMessage("§e/astools remove §7- Befehle löschen");
+        p.sendMessage("§e/astools reload §7- Konfig neu laden");
+        p.sendMessage("§8§m---------------------------------------");
        return true;
    }
 }
--- a/src/main/java/de/nexuslobby/modules/armorstandtools/DynamicArmorStandModule.java
+++ b/src/main/java/de/nexuslobby/modules/armorstandtools/DynamicArmorStandModule.java
@@ -0,0 +1,119 @@
+package de.nexuslobby.modules.armorstandtools;
+
+import de.nexuslobby.NexusLobby;
+import de.nexuslobby.api.Module;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.World;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Entity;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.persistence.PersistentDataType;
+
+import java.time.LocalTime;
+
+/**
+ * DynamicArmorStandModule
+ * Reagiert auf Uhrzeit und Wetter.
+ * Nutzt PersistentData, damit die Einstellung auch nach einem Server-Neustart bleibt.
+ */
+public class DynamicArmorStandModule implements Module {
+
+    // Der Key muss mit dem Command übereinstimmen oder das Modul nutzt Tags.
+    // Wir nutzen hier PersistentData, da es sicherer ist als Tags.
+    private final NamespacedKey npcKey = new NamespacedKey(NexusLobby.getInstance(), "dynamic_npc");
+
+    @Override
+    public String getName() {
+        return "DynamicArmorStands";
+    }
+
+    @Override
+    public void onEnable() {
+        startUpdateTask();
+        Bukkit.getLogger().info("[NexusLobby] DynamicArmorStandModule wurde aktiviert.");
+    }
+
+    /**
+     * Startet einen Timer, der alle 5 Sekunden (100 Ticks) prüft.
+     */
+    private void startUpdateTask() {
+        Bukkit.getScheduler().runTaskTimer(NexusLobby.getInstance(), () -> {
+            updateAllArmorStands();
+        }, 100L, 100L); // Alle 5 Sekunden statt 2 Minuten
+    }
+
+    public void updateAllArmorStands() {
+        int hour = LocalTime.now().getHour();
+        
+        for (World world : Bukkit.getWorlds()) {
+            boolean isRaining = world.hasStorm();
+
+            for (Entity entity : world.getEntities()) {
+                if (entity instanceof ArmorStand armorStand) {
+                    // PRÜFUNG: Entweder PersistentData ODER Scoreboard-Tag "as_dynamic"
+                    if (armorStand.getPersistentDataContainer().has(npcKey, PersistentDataType.BYTE) || 
+                        armorStand.getScoreboardTags().contains("as_dynamic")) {
+                        
+                        applyDynamicChanges(armorStand, hour, isRaining);
+                    }
+                }
+            }
+        }
+    }
+
+    private void applyDynamicChanges(ArmorStand as, int hour, boolean isRaining) {
+        // --- ZEIT-LOGIK (Nacht: 20:00 - 06:00) ---
+        if (hour >= 20 || hour <= 6) {
+            if (as.getEquipment().getItemInOffHand().getType() != Material.TORCH) {
+                as.getEquipment().setItemInOffHand(new ItemStack(Material.TORCH));
+            }
+        } else {
+            if (as.getEquipment().getItemInOffHand().getType() == Material.TORCH) {
+                as.getEquipment().setItemInOffHand(null);
+            }
+        }
+
+        // --- WETTER-LOGIK (Regen) ---
+        if (isRaining) {
+            if (as.getEquipment().getHelmet() == null || as.getEquipment().getHelmet().getType() != Material.LEATHER_HELMET) {
+                as.getEquipment().setHelmet(new ItemStack(Material.LEATHER_HELMET));
+            }
+        } else {
+            // Nur ausziehen, wenn es hellwach ist und nicht regnet
+            if (hour < 20 && hour > 6) {
+                if (as.getEquipment().getHelmet() != null && as.getEquipment().getHelmet().getType() == Material.LEATHER_HELMET) {
+                    as.getEquipment().setHelmet(null);
+                }
+            }
+        }
+    }
+
+    /**
+     * Schaltet den Status um. Wird vom ArmorStandCommand aufgerufen.
+     */
+    public void toggleDynamicStatus(ArmorStand as) {
+        if (as.getPersistentDataContainer().has(npcKey, PersistentDataType.BYTE)) {
+            // Deaktivieren
+            as.getPersistentDataContainer().remove(npcKey);
+            as.removeScoreboardTag("as_dynamic"); // Zur Sicherheit beides entfernen
+            as.getEquipment().setItemInOffHand(null);
+            as.getEquipment().setHelmet(null);
+        } else {
+            // Aktivieren
+            as.getPersistentDataContainer().set(npcKey, PersistentDataType.BYTE, (byte) 1);
+            as.addScoreboardTag("as_dynamic");
+            
+            // Sofortige visuelle Rückmeldung
+            int hour = LocalTime.now().getHour();
+            boolean isRaining = as.getWorld().hasStorm();
+            applyDynamicChanges(as, hour, isRaining);
+        }
+    }
+
+    @Override
+    public void onDisable() {
+        // Nichts zu tun
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/gadgets/Balloon.java
+++ b/src/main/java/de/nexuslobby/modules/gadgets/Balloon.java
@@ -0,0 +1,77 @@
+package de.nexuslobby.modules.gadgets;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.Vector;
+
+import java.util.UUID;
+
+public class Balloon {
+
+    private final UUID playerUUID;
+    private final LivingEntity balloonEntity;
+    private final ArmorStand headStand;
+
+    public Balloon(Player player, Material balloonMaterial) {
+        this.playerUUID = player.getUniqueId();
+        Location loc = player.getLocation().add(0, 2, 0);
+
+        // Das unsichtbare Träger-Entity
+        this.balloonEntity = (LivingEntity) loc.getWorld().spawnEntity(loc, EntityType.PIG);
+        this.balloonEntity.setInvisible(true);
+        this.balloonEntity.setSilent(true);
+        this.balloonEntity.setInvulnerable(true);
+        this.balloonEntity.setGravity(false);
+        this.balloonEntity.setLeashHolder(player);
+
+        // Der ArmorStand, der den farbigen Block trägt
+        this.headStand = (ArmorStand) loc.getWorld().spawnEntity(loc, EntityType.ARMOR_STAND);
+        this.headStand.setVisible(false);
+        this.headStand.setGravity(false);
+        this.headStand.setMarker(true);
+        
+        // Hier wird das übergebene Material gesetzt (z.B. RED_WOOL, BLUE_WOOL etc.)
+        this.headStand.setHelmet(new ItemStack(balloonMaterial));
+    }
+
+    public void update() {
+        Player player = org.bukkit.Bukkit.getPlayer(playerUUID);
+
+        if (player == null || !player.isOnline() || balloonEntity == null || !balloonEntity.isValid()) {
+            remove();
+            return;
+        }
+
+        if (!balloonEntity.isLeashed()) {
+            remove();
+            return;
+        }
+
+        Location targetLoc = player.getLocation().clone().add(0, 2.5, 0);
+        Vector direction = targetLoc.toVector().subtract(balloonEntity.getLocation().toVector());
+        double distance = direction.length();
+
+        if (distance > 5) {
+            balloonEntity.teleport(targetLoc);
+        } else if (distance > 0.1) {
+            balloonEntity.setVelocity(direction.multiply(0.4));
+        }
+
+        headStand.teleport(balloonEntity.getLocation().clone().subtract(0, 1.5, 0));
+    }
+
+    public void remove() {
+        if (balloonEntity != null) {
+            balloonEntity.setLeashHolder(null);
+            balloonEntity.remove();
+        }
+        if (headStand != null) {
+            headStand.remove();
+        }
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/gadgets/ChickenRain.java
+++ b/src/main/java/de/nexuslobby/modules/gadgets/ChickenRain.java
@@ -0,0 +1,54 @@
+package de.nexuslobby.modules.gadgets;
+
+import de.nexuslobby.NexusLobby;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Particle;
+import org.bukkit.Sound;
+import org.bukkit.entity.Chicken;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.util.Random;
+
+public class ChickenRain {
+
+    public static void start(Player player) {
+        new BukkitRunnable() {
+            int ticks = 0;
+            final Random random = new Random();
+
+            @Override
+            public void run() {
+                if (!player.isOnline() || ticks > 100) { // 100 Ticks = 5 Sekunden
+                    this.cancel();
+                    return;
+                }
+
+                // Alle 2 Ticks ein Huhn spawnen
+                if (ticks % 2 == 0) {
+                    Location spawnLoc = player.getLocation().add(
+                        (random.nextDouble() - 0.5) * 4, 
+                        4.0, 
+                        (random.nextDouble() - 0.5) * 4
+                    );
+
+                    Chicken chicken = (Chicken) spawnLoc.getWorld().spawnEntity(spawnLoc, EntityType.CHICKEN);
+                    chicken.setBaby();
+                    chicken.setInvulnerable(true);
+
+                    // Nach 1.5 Sekunden "ploppt" das Huhn
+                    Bukkit.getScheduler().runTaskLater(NexusLobby.getInstance(), () -> {
+                        if (chicken.isValid()) {
+                            chicken.getWorld().spawnParticle(Particle.CLOUD, chicken.getLocation(), 5, 0.2, 0.2, 0.2, 0.1);
+                            chicken.getWorld().playSound(chicken.getLocation(), Sound.ENTITY_CHICKEN_EGG, 1.0f, 1.5f);
+                            chicken.remove();
+                        }
+                    }, 30L);
+                }
+                ticks++;
+            }
+        }.runTaskTimer(NexusLobby.getInstance(), 0L, 1L);
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/gadgets/GadgetModule.java
+++ b/src/main/java/de/nexuslobby/modules/gadgets/GadgetModule.java
@@ -0,0 +1,297 @@
+package de.nexuslobby.modules.gadgets;
+
+import de.nexuslobby.NexusLobby;
+import de.nexuslobby.api.Module;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.Particle;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.player.PlayerFishEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+public class GadgetModule implements Module, Listener {
+
+    private final Map<UUID, Balloon> activeBalloons = new HashMap<>();
+    private final Map<UUID, ParticleEffect> activeEffects = new HashMap<>();
+    private final Set<UUID> activeShields = new HashSet<>();
+
+    private final String MAIN_TITLE = "§b§lGadgets §8- §7Menü";
+    private final String BALLOON_TITLE = "§b§lGadgets §8- §eBallons";
+    private final String PARTICLE_TITLE = "§b§lGadgets §8- §dPartikel";
+    private final String FUN_TITLE = "§b§lGadgets §8- §6Lustiges";
+    private final String HAT_TITLE = "§b§lGadgets §8- §aHüte & Köpfe";
+    private final String PET_TITLE = "§b§lGadgets §8- §dBegleiter";
+
+    @Override
+    public String getName() { return "Gadgets"; }
+
+    @Override
+    public void onEnable() {
+        Bukkit.getPluginManager().registerEvents(this, NexusLobby.getInstance());
+        
+        Bukkit.getScheduler().runTaskTimer(NexusLobby.getInstance(), () -> {
+            PetManager.updatePets();
+            activeBalloons.values().forEach(Balloon::update);
+            
+            for (Player p : Bukkit.getOnlinePlayers()) {
+                UUID uuid = p.getUniqueId();
+                handleSpecialHatEffects(p);
+                if (activeEffects.containsKey(uuid)) activeEffects.get(uuid).update(p);
+                if (activeShields.contains(uuid)) ShieldTask.handleShield(p);
+            }
+        }, 1L, 1L);
+    }
+
+    private void handleSpecialHatEffects(Player p) {
+        ItemStack hat = p.getInventory().getHelmet();
+        if (hat == null || hat.getType() == Material.AIR) return;
+
+        switch (hat.getType()) {
+            case CAMPFIRE:
+                p.getWorld().spawnParticle(Particle.CAMPFIRE_COSY_SMOKE, p.getLocation().add(0, 2.2, 0), 1, 0.05, 0.05, 0.05, 0.02);
+                break;
+            case SPAWNER:
+                p.getWorld().spawnParticle(Particle.FLAME, p.getLocation().add(0, 2.1, 0), 1, 0.12, 0.12, 0.12, 0.02);
+                break;
+            case SEA_LANTERN:
+            case BEACON:
+                p.getWorld().spawnParticle(Particle.END_ROD, p.getLocation().add(0, 2.1, 0), 1, 0.1, 0.1, 0.1, 0.03);
+                break;
+            case ENCHANTING_TABLE:
+                p.getWorld().spawnParticle(Particle.ENCHANT, p.getLocation().add(0, 2.3, 0), 1, 0.2, 0.2, 0.2, 0.5);
+                break;
+        }
+    }
+
+    public void openGUI(Player player) {
+        Inventory gui = Bukkit.createInventory(null, 27, MAIN_TITLE);
+        fillEdges(gui);
+
+        gui.setItem(10, createItem(Material.LEAD, "§e§lBallons", "§7Wähle einen fliegenden Begleiter"));
+        gui.setItem(11, createItem(Material.GOLDEN_HELMET, "§a§lHüte", "§7Setze dir etwas auf den Kopf"));
+        gui.setItem(13, createItem(Material.BONE, "§d§lBegleiter", "§7Echte Tiere, die dir folgen"));
+        gui.setItem(15, createItem(Material.FIREWORK_ROCKET, "§6§lLustiges", "§7Witzige Effekte"));
+        gui.setItem(16, createItem(Material.NETHER_STAR, "§d§lPartikel", "§7Magische Auren & Effekte"));
+        
+        gui.setItem(22, createItem(Material.BARRIER, "§c§lStopp", "§7Alle Gadgets entfernen"));
+        player.openInventory(gui);
+    }
+
+    private void openHatGUI(Player player) {
+        Inventory gui = Bukkit.createInventory(null, 45, HAT_TITLE);
+        fillEdges(gui);
+
+        gui.setItem(10, createItem(Material.JACK_O_LANTERN, "§6Kürbis-Hut", "§7Es ist immer Halloween!"));
+        gui.setItem(11, createItem(Material.SEA_LANTERN, "§bMeeres-Leuchten", "§7§oEffekt: Glitzern"));
+        gui.setItem(12, createItem(Material.GLOWSTONE, "§eGlowstone-Kopf", "§7Werde zur Lampe"));
+        gui.setItem(13, createItem(Material.TNT, "§cExplosiv-Hut", "§7Vorsicht, heiß!"));
+        gui.setItem(14, createItem(Material.GLASS, "§fAstronaut", "§7Bereit für den Mond?"));
+        gui.setItem(15, createItem(Material.DRAGON_HEAD, "§5Enderdrache", "§7Der König der Lüfte"));
+        gui.setItem(16, createItem(Material.CAKE, "§dKuchen-Kopf", "§7Jeder mag Kuchen!"));
+
+        gui.setItem(19, createItem(Material.SLIME_BLOCK, "§aGlibber-Block", "§7Ziemlich klebrig..."));
+        gui.setItem(20, createItem(Material.MELON, "§aMelonen-Helm", "§7Frisch und saftig"));
+        gui.setItem(21, createItem(Material.HAY_BLOCK, "§eStrohhut", "§7Sommer auf dem Land"));
+        gui.setItem(22, createItem(Material.SPAWNER, "§8Monster-Käfig", "§7§oEffekt: Flammen")); 
+        gui.setItem(23, createItem(Material.CRAFTING_TABLE, "§6Werkbank", "§7Immer am Basteln"));
+        gui.setItem(24, createItem(Material.BOOKSHELF, "§fBücherregal", "§7Ein wahrer Schlaukopf"));
+        gui.setItem(25, createItem(Material.HONEY_BLOCK, "§6Honig-Hut", "§7Süß und klebrig"));
+
+        gui.setItem(28, createItem(Material.GOLD_BLOCK, "§6Gold-Bonze", "§7Zeig was du hast"));
+        gui.setItem(29, createItem(Material.DIAMOND_ORE, "§bDiamant-Erz", "§7Bau mich bloß nicht ab!"));
+        gui.setItem(30, createItem(Material.BEACON, "§fLeuchtfeuer", "§7§oEffekt: Glitzern"));
+        gui.setItem(31, createItem(Material.CONDUIT, "§3Auge des Meeres", "§7Die Macht von Atlantis"));
+        gui.setItem(32, createItem(Material.ENCHANTING_TABLE, "§dMagier", "§7§oEffekt: Runen"));
+        gui.setItem(33, createItem(Material.CAMPFIRE, "§cHeißer Kopf", "§7§oEffekt: Rauch"));
+        gui.setItem(34, createItem(Material.SKELETON_SKULL, "§7Skelett", "§7Ein wenig gruselig"));
+
+        gui.setItem(40, createItem(Material.ARROW, "§7Zurück", "§8Zum Hauptmenü"));
+        player.openInventory(gui);
+    }
+
+    private void openPetGUI(Player player) {
+        Inventory gui = Bukkit.createInventory(null, 27, PET_TITLE);
+        fillEdges(gui);
+        gui.setItem(11, createItem(Material.BONE, "§fWolf", "§7Ein treuer Begleiter"));
+        gui.setItem(13, createItem(Material.CAT_SPAWN_EGG, "§6Katze", "§7Ein verschmuster Freund"));
+        gui.setItem(15, createItem(Material.PANDA_SPAWN_EGG, "§aPanda", "§7Ein gemütlicher Zeitgenosse"));
+        gui.setItem(22, createItem(Material.ARROW, "§7Zurück", "§8Zum Hauptmenü"));
+        player.openInventory(gui);
+    }
+
+    private void openBalloonGUI(Player player) {
+        Inventory gui = Bukkit.createInventory(null, 36, BALLOON_TITLE);
+        fillEdges(gui);
+        Material[] wools = {Material.WHITE_WOOL, Material.ORANGE_WOOL, Material.MAGENTA_WOOL, Material.LIGHT_BLUE_WOOL, 
+                            Material.YELLOW_WOOL, Material.LIME_WOOL, Material.PINK_WOOL, Material.GRAY_WOOL, 
+                            Material.CYAN_WOOL, Material.PURPLE_WOOL, Material.BLUE_WOOL, Material.BROWN_WOOL, 
+                            Material.GREEN_WOOL, Material.RED_WOOL};
+        int slot = 10;
+        for (Material m : wools) {
+            if (slot == 17) slot = 19;
+            gui.setItem(slot++, createItem(m, "§fBallon: " + m.name().replace("_WOOL", ""), "§7Klicke zum Ausrüsten"));
+        }
+        gui.setItem(31, createItem(Material.ARROW, "§7Zurück", "§8Zum Hauptmenü"));
+        player.openInventory(gui);
+    }
+
+    private void openParticleGUI(Player player) {
+        Inventory gui = Bukkit.createInventory(null, 27, PARTICLE_TITLE);
+        fillEdges(gui);
+        gui.setItem(11, createItem(Material.POPPY, "§cHerzchen-Aura", "§7Verbreite Liebe in der Lobby"));
+        gui.setItem(13, createItem(Material.BLAZE_POWDER, "§6Flammen-Ring", "§7Lass es brennen!"));
+        gui.setItem(15, createItem(Material.WATER_BUCKET, "§bRegenwolke", "§7Deine persönliche Abkühlung"));
+        gui.setItem(22, createItem(Material.ARROW, "§7Zurück", "§8Zum Hauptmenü"));
+        player.openInventory(gui);
+    }
+
+    private void openFunGUI(Player player) {
+        Inventory gui = Bukkit.createInventory(null, 27, FUN_TITLE);
+        fillEdges(gui);
+        gui.setItem(11, createItem(Material.FISHING_ROD, "§b§lEnterhaken", "§7Zieh dich durch die Luft!"));
+        gui.setItem(13, createItem(Material.SHIELD, "§5§lSchutzzone", "§7Halte andere auf Distanz"));
+        gui.setItem(15, createItem(Material.EGG, "§f§lChicken-Rain", "§7Gack-Gack! Hühner überall!"));
+        gui.setItem(22, createItem(Material.ARROW, "§7Zurück", "§8Zum Hauptmenü"));
+        player.openInventory(gui);
+    }
+
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) {
+        String title = event.getView().getTitle();
+        if (!title.startsWith("§b§lGadgets")) return;
+        event.setCancelled(true);
+        Player player = (Player) event.getWhoClicked();
+        ItemStack item = event.getCurrentItem();
+        if (item == null || item.getType() == Material.AIR) return;
+
+        if (item.getType() == Material.ARROW) { openGUI(player); return; }
+
+        if (title.equals(MAIN_TITLE)) {
+            if (item.getType() == Material.LEAD) openBalloonGUI(player);
+            else if (item.getType() == Material.GOLDEN_HELMET) openHatGUI(player);
+            else if (item.getType() == Material.BONE) openPetGUI(player);
+            else if (item.getType() == Material.NETHER_STAR) openParticleGUI(player);
+            else if (item.getType() == Material.FIREWORK_ROCKET) openFunGUI(player);
+            else if (item.getType() == Material.BARRIER) { removeGadgets(player); player.closeInventory(); }
+        }
+        else if (title.equals(HAT_TITLE)) {
+            if (item.getType() != Material.GRAY_STAINED_GLASS_PANE) {
+                HatManager.setHat(player, item.getType(), item.getItemMeta().getDisplayName());
+                player.playSound(player.getLocation(), Sound.ITEM_ARMOR_EQUIP_GENERIC, 1, 1);
+                player.closeInventory();
+            }
+        }
+        else if (title.equals(PET_TITLE)) {
+            if (item.getType() == Material.BONE) PetManager.spawnEntityPet(player, "WOLF");
+            else if (item.getType() == Material.CAT_SPAWN_EGG) PetManager.spawnEntityPet(player, "CAT");
+            else if (item.getType() == Material.PANDA_SPAWN_EGG) PetManager.spawnEntityPet(player, "PANDA");
+            player.sendMessage("§8[§6Nexus§8] §dDein Pet wurde gerufen!");
+            player.closeInventory();
+        }
+        else if (title.equals(BALLOON_TITLE)) {
+            if (item.getType().toString().endsWith("_WOOL")) {
+                if (activeBalloons.containsKey(player.getUniqueId())) activeBalloons.get(player.getUniqueId()).remove();
+                activeBalloons.put(player.getUniqueId(), new Balloon(player, item.getType()));
+                player.sendMessage("§8[§6Nexus§8] §aBallon aktiviert!");
+                player.closeInventory();
+            }
+        }
+        else if (title.equals(PARTICLE_TITLE)) {
+            if (item.getType() == Material.POPPY) activeEffects.put(player.getUniqueId(), new ParticleEffect("hearts"));
+            else if (item.getType() == Material.BLAZE_POWDER) activeEffects.put(player.getUniqueId(), new ParticleEffect("flames"));
+            else if (item.getType() == Material.WATER_BUCKET) activeEffects.put(player.getUniqueId(), new ParticleEffect("cloud"));
+            player.sendMessage("§8[§6Nexus§8] §aPartikel aktiviert!");
+            player.closeInventory();
+        }
+        else if (title.equals(FUN_TITLE)) {
+            if (item.getType() == Material.EGG) {
+                ChickenRain.start(player);
+                player.sendMessage("§8[§6Nexus§8] §fHühnerregen gestartet!");
+                player.closeInventory();
+            } else if (item.getType() == Material.FISHING_ROD) {
+                player.getInventory().addItem(createItem(Material.FISHING_ROD, "§b§lEnterhaken", "§7Rechtsklick zum Katapultieren"));
+                player.closeInventory();
+            } else if (item.getType() == Material.SHIELD) {
+                if (activeShields.contains(player.getUniqueId())) {
+                    activeShields.remove(player.getUniqueId());
+                    player.sendMessage("§8[§6Nexus§8] §cSchutzzone deaktiviert.");
+                } else {
+                    activeShields.add(player.getUniqueId());
+                    player.sendMessage("§8[§6Nexus§8] §5Schutzzone aktiviert!");
+                }
+                player.closeInventory();
+            }
+        }
+    }
+
+    @EventHandler
+    public void onFish(PlayerFishEvent event) {
+        Player player = event.getPlayer();
+        ItemStack item = player.getInventory().getItemInMainHand();
+        if (item != null && item.getType() == Material.FISHING_ROD && item.hasItemMeta() && item.getItemMeta().getDisplayName().equals("§b§lEnterhaken")) {
+            if (event.getState() == PlayerFishEvent.State.IN_GROUND || event.getState() == PlayerFishEvent.State.REEL_IN || event.getState() == PlayerFishEvent.State.CAUGHT_ENTITY) {
+                if (event.getHook() != null) {
+                    GrapplingHook.pullPlayer(player, event.getHook().getLocation());
+                }
+            }
+        }
+    }
+
+    private void removeGadgets(Player player) {
+        if (activeBalloons.containsKey(player.getUniqueId())) {
+            activeBalloons.get(player.getUniqueId()).remove();
+            activeBalloons.remove(player.getUniqueId());
+        }
+        activeEffects.remove(player.getUniqueId());
+        activeShields.remove(player.getUniqueId());
+        PetManager.removePet(player);
+        HatManager.removeHat(player);
+        player.getInventory().remove(Material.FISHING_ROD);
+        player.sendMessage("§8[§6Nexus§8] §cAlle Gadgets abgelegt.");
+    }
+
+    private void fillEdges(Inventory inv) {
+        ItemStack glass = createItem(Material.GRAY_STAINED_GLASS_PANE, " ", null);
+        for (int i = 0; i < inv.getSize(); i++) {
+            if (i < 9 || i >= inv.getSize() - 9 || i % 9 == 0 || (i + 1) % 9 == 0) inv.setItem(i, glass);
+        }
+    }
+
+    private ItemStack createItem(Material mat, String name, String lore) {
+        ItemStack item = new ItemStack(mat);
+        ItemMeta meta = item.getItemMeta();
+        if (meta != null) {
+            meta.setDisplayName(name);
+            if (lore != null) {
+                List<String> l = new ArrayList<>();
+                l.add(lore);
+                meta.setLore(l);
+            }
+            item.setItemMeta(meta);
+        }
+        return item;
+    }
+
+    @Override
+    public void onDisable() {
+        PetManager.clearAll();
+        activeBalloons.values().forEach(Balloon::remove);
+        activeBalloons.clear();
+        activeEffects.clear();
+        activeShields.clear();
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/gadgets/GrapplingHook.java
+++ b/src/main/java/de/nexuslobby/modules/gadgets/GrapplingHook.java
@@ -0,0 +1,37 @@
+package de.nexuslobby.modules.gadgets;
+
+import org.bukkit.Location;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.util.Vector;
+
+public class GrapplingHook {
+
+    public static void pullPlayer(Player player, Location target) {
+        Location playerLoc = player.getLocation();
+        
+        // Vektor vom Spieler zum Ziel berechnen
+        double distance = target.distance(playerLoc);
+        
+        // Wenn das Ziel zu nah oder zu weit weg ist, nichts tun
+        if (distance < 2 || distance > 50) return;
+
+        // Berechnung des Wurfs (Vektor)
+        Vector v = target.toVector().subtract(playerLoc.toVector());
+        
+        // Den Vektor normalisieren und skalieren (Stärke des Zugs)
+        v.multiply(0.3); // Basis-Geschwindigkeit
+        v.setY(v.getY() * 0.6 + 0.5); // Etwas mehr Höhe für den Bogen-Effekt
+        
+        // Geschwindigkeit begrenzen, damit man nicht aus der Map schießt
+        if (v.length() > 2.5) {
+            v.normalize().multiply(2.5);
+        }
+
+        player.setVelocity(v);
+        
+        // Sound-Effekt für das "Ziehen"
+        player.playSound(playerLoc, Sound.ENTITY_WIND_CHARGE_WIND_BURST, 1.0f, 1.2f);
+        player.playSound(playerLoc, Sound.ITEM_TRIDENT_RIPTIDE_1, 0.5f, 1.5f);
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/gadgets/HatManager.java
+++ b/src/main/java/de/nexuslobby/modules/gadgets/HatManager.java
@@ -0,0 +1,26 @@
+package de.nexuslobby.modules.gadgets;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+public class HatManager {
+
+    public static void setHat(Player player, Material material, String name) {
+        ItemStack hat = new ItemStack(material);
+        ItemMeta meta = hat.getItemMeta();
+        if (meta != null) {
+            meta.setDisplayName("§6Hut: " + name);
+            hat.setItemMeta(meta);
+        }
+        
+        // Den Gegenstand auf den Kopf setzen
+        player.getInventory().setHelmet(hat);
+        player.sendMessage("§8[§6Nexus§8] §aDu trägst nun: " + name);
+    }
+
+    public static void removeHat(Player player) {
+        player.getInventory().setHelmet(null);
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/gadgets/ParticleEffect.java
+++ b/src/main/java/de/nexuslobby/modules/gadgets/ParticleEffect.java
@@ -0,0 +1,31 @@
+package de.nexuslobby.modules.gadgets;
+
+import org.bukkit.Location;
+import org.bukkit.Particle;
+import org.bukkit.entity.Player;
+
+public class ParticleEffect {
+    private final String type;
+    private double angle = 0;
+
+    public ParticleEffect(String type) { this.type = type; }
+
+    public void update(Player player) {
+        Location loc = player.getLocation();
+        switch (type.toLowerCase()) {
+            case "hearts":
+                player.getWorld().spawnParticle(Particle.HEART, loc.clone().add(0, 2.2, 0), 1, 0.3, 0.3, 0.3, 0);
+                break;
+            case "flames":
+                double x = 0.6 * Math.cos(angle);
+                double z = 0.6 * Math.sin(angle);
+                player.getWorld().spawnParticle(Particle.FLAME, loc.clone().add(x, 0.1, z), 1, 0, 0, 0, 0);
+                angle += 0.2;
+                break;
+            case "cloud":
+                player.getWorld().spawnParticle(Particle.CLOUD, loc.clone().add(0, 2.5, 0), 2, 0.2, 0.05, 0.2, 0);
+                player.getWorld().spawnParticle(Particle.FALLING_WATER, loc.clone().add(0, 2.4, 0), 1, 0.1, 0, 0.1, 0);
+                break;
+        }
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/gadgets/PetManager.java
+++ b/src/main/java/de/nexuslobby/modules/gadgets/PetManager.java
@@ -0,0 +1,138 @@
+package de.nexuslobby.modules.gadgets;
+
+import de.nexuslobby.NexusLobby;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Tameable;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityTargetEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class PetManager implements Listener {
+
+    private static final Map<UUID, Entity> activePets = new HashMap<>();
+
+    public PetManager() {
+        Bukkit.getPluginManager().registerEvents(this, NexusLobby.getInstance());
+    }
+
+    /**
+     * Spawnt ein echtes Tier-Entity für den Spieler.
+     */
+    public static void spawnEntityPet(Player player, String type) {
+        removePet(player);
+
+        EntityType entityType;
+        try {
+            entityType = EntityType.valueOf(type);
+        } catch (IllegalArgumentException e) {
+            player.sendMessage("§cFehler: Tier-Typ nicht gefunden.");
+            return;
+        }
+
+        Location loc = player.getLocation();
+        Entity pet = player.getWorld().spawnEntity(loc, entityType);
+
+        pet.setCustomName("§d" + player.getName() + "'s " + capitalize(type.toLowerCase()));
+        pet.setCustomNameVisible(true);
+        pet.setInvulnerable(true);
+        pet.setPersistent(false);
+
+        if (pet instanceof LivingEntity) {
+            LivingEntity le = (LivingEntity) pet;
+            le.setRemoveWhenFarAway(false);
+            
+            // Verhindert, dass das Pet andere angreift
+            if (le instanceof Tameable) {
+                ((Tameable) le).setTamed(true);
+                ((Tameable) le).setOwner(player);
+            }
+        }
+
+        activePets.put(player.getUniqueId(), pet);
+    }
+
+    /**
+     * Steuert das Folgen der Tiere. Wird vom GadgetModule-Timer aufgerufen.
+     */
+    public static void updatePets() {
+        for (Map.Entry<UUID, Entity> entry : activePets.entrySet()) {
+            Player owner = Bukkit.getPlayer(entry.getKey());
+            Entity pet = entry.getValue();
+
+            if (owner == null || !owner.isOnline() || pet.isDead()) {
+                continue;
+            }
+
+            // Wenn das Pet in einer anderen Welt ist oder zu weit weg, teleportiere es
+            if (!pet.getWorld().equals(owner.getWorld()) || pet.getLocation().distance(owner.getLocation()) > 10) {
+                pet.teleport(owner.getLocation());
+                continue;
+            }
+
+            // Sanftes Folgen: Wenn das Pet weiter als 3 Blöcke weg ist
+            if (pet.getLocation().distance(owner.getLocation()) > 3) {
+                Location target = owner.getLocation().clone().add(owner.getLocation().getDirection().multiply(-1.5));
+                target.setY(owner.getLocation().getY());
+                
+                // Teleportiert das Pet leicht zum Ziel (simuliert Laufen)
+                pet.teleport(pet.getLocation().add(target.toVector().subtract(pet.getLocation().toVector()).normalize().multiply(0.2)));
+                
+                // Blickrichtung anpassen
+                Location lookAt = pet.getLocation();
+                lookAt.setDirection(owner.getLocation().toVector().subtract(pet.getLocation().toVector()));
+                pet.teleport(lookAt);
+            }
+        }
+    }
+
+    public static void removePet(Player player) {
+        if (activePets.containsKey(player.getUniqueId())) {
+            activePets.get(player.getUniqueId()).remove();
+            activePets.remove(player.getUniqueId());
+        }
+    }
+
+    public static void clearAll() {
+        for (Entity pet : activePets.values()) {
+            pet.remove();
+        }
+        activePets.clear();
+    }
+
+    private static String capitalize(String str) {
+        if (str == null || str.isEmpty()) return str;
+        return str.substring(0, 1).toUpperCase() + str.substring(1);
+    }
+
+    // --- Events um die Pets zu schützen ---
+
+    @EventHandler
+    public void onPetDamage(EntityDamageEvent event) {
+        if (activePets.containsValue(event.getEntity())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onPetTarget(EntityTargetEvent event) {
+        if (activePets.containsValue(event.getEntity())) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onQuit(PlayerQuitEvent event) {
+        removePet(event.getPlayer());
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/gadgets/ShieldTask.java
+++ b/src/main/java/de/nexuslobby/modules/gadgets/ShieldTask.java
@@ -0,0 +1,32 @@
+package de.nexuslobby.modules.gadgets;
+
+import org.bukkit.Particle;
+import org.bukkit.Sound;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.util.Vector;
+
+public class ShieldTask {
+
+    public static void handleShield(Player owner) {
+        // Erzeuge einen Partikel-Ring um den Spieler
+        for (double i = 0; i < Math.PI * 2; i += Math.PI / 8) {
+            double x = Math.cos(i) * 2.2;
+            double z = Math.sin(i) * 2.2;
+            owner.getWorld().spawnParticle(Particle.WITCH, owner.getLocation().add(x, 0.5, z), 1, 0, 0, 0, 0);
+        }
+
+        // Stoße andere Spieler weg
+        for (Entity entity : owner.getNearbyEntities(2.2, 2.0, 2.2)) {
+            if (entity instanceof Player && entity != owner) {
+                Player target = (Player) entity;
+                
+                Vector direction = target.getLocation().toVector().subtract(owner.getLocation().toVector()).normalize();
+                direction.multiply(0.4).setY(0.2);
+                
+                target.setVelocity(direction);
+                target.playSound(target.getLocation(), Sound.ENTITY_CHICKEN_EGG, 0.5f, 0.5f);
+            }
+        }
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/hologram/HoloCommand.java
+++ b/src/main/java/de/nexuslobby/modules/hologram/HoloCommand.java
@@ -0,0 +1,85 @@
+package de.nexuslobby.commands;
+
+import de.nexuslobby.modules.hologram.HologramModule;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class HoloCommand implements CommandExecutor {
+
+    private final HologramModule module;
+
+    public HoloCommand(HologramModule module) {
+        this.module = module;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player player)) return true;
+
+        if (!player.hasPermission("nexuslobby.hologram")) {
+            player.sendMessage("§8[§6Nexus§8] §cKeine Rechte.");
+            return true;
+        }
+
+        if (args.length < 1) {
+            sendHelp(player);
+            return true;
+        }
+
+        if (args[0].equalsIgnoreCase("create")) {
+            // Wir brauchen id, typ und mindestens ein Wort Text
+            if (args.length < 4) {
+                player.sendMessage("§cNutze: /holo create <id> <NONE|FAST|SLOW> <text>");
+                return true;
+            }
+            
+            String id = args[1];
+            // Der Typ (args[2]) wird im neuen System ignoriert, da wir Seiten nutzen
+            
+            StringBuilder sb = new StringBuilder();
+            for (int i = 3; i < args.length; i++) {
+                sb.append(args[i]).append(i == args.length - 1 ? "" : " ");
+            }
+            
+            String fullText = sb.toString().trim();
+            List<String> pages = new ArrayList<>();
+
+            // Support für mehrere Seiten via ";"
+            if (fullText.contains(";")) {
+                pages.addAll(Arrays.asList(fullText.split(";")));
+            } else {
+                pages.add(fullText);
+            }
+            
+            // Aufruf der neuen Methode mit List<String>
+            module.createHologram(id, player.getLocation(), pages);
+            player.sendMessage("§8[§6Nexus§8] §aHologramm §e" + id + " §aerstellt (" + pages.size() + " Seiten).");
+        } 
+        else if (args[0].equalsIgnoreCase("delete")) {
+            if (args.length < 2) {
+                player.sendMessage("§cBitte gib eine ID an: /holo delete <id>");
+                return true;
+            }
+            module.removeHologram(args[1]);
+            player.sendMessage("§8[§6Nexus§8] §cHologramm §e" + args[1] + " §ageloescht.");
+        } else {
+            sendHelp(player);
+        }
+
+        return true;
+    }
+
+    private void sendHelp(Player player) {
+        player.sendMessage("§8§m-----------§r §6Hologramme §8§m-----------");
+        player.sendMessage("§e/holo create <id> <NONE|FAST|SLOW> <text>");
+        player.sendMessage("§e/holo delete <id>");
+        player.sendMessage("§7Nutze §b; §7für neue Seiten.");
+        player.sendMessage("§7Nutze §b\\n §7für Zeilenumbruch.");
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/hologram/HologramModule.java
+++ b/src/main/java/de/nexuslobby/modules/hologram/HologramModule.java
@@ -0,0 +1,134 @@
+package de.nexuslobby.modules.hologram;
+
+import de.nexuslobby.NexusLobby;
+import de.nexuslobby.api.Module;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class HologramModule implements Module, Listener {
+
+    private final Map<String, NexusHologram> holograms = new ConcurrentHashMap<>();
+    private File file;
+    private FileConfiguration config;
+
+    @Override
+    public String getName() { return "Holograms"; }
+
+    @Override
+    public void onEnable() {
+        loadConfig();
+        loadHolograms();
+        Bukkit.getPluginManager().registerEvents(this, NexusLobby.getInstance());
+
+        Bukkit.getScheduler().runTaskTimer(NexusLobby.getInstance(), () -> {
+            for (Player player : Bukkit.getOnlinePlayers()) {
+                holograms.values().forEach(h -> h.renderForPlayer(player));
+            }
+        }, 20L, 5L);
+    }
+
+    private void loadConfig() {
+        file = new File(NexusLobby.getInstance().getDataFolder(), "holograms.yml");
+        config = YamlConfiguration.loadConfiguration(file);
+    }
+
+    private void loadHolograms() {
+        holograms.values().forEach(NexusHologram::removeAll);
+        holograms.clear();
+        for (String id : config.getKeys(false)) {
+            World world = Bukkit.getWorld(config.getString(id + ".world", "world"));
+            if (world == null) continue;
+            Location loc = new Location(world, config.getDouble(id + ".x"), config.getDouble(id + ".y"), config.getDouble(id + ".z"));
+            
+            List<String> pages;
+            if (config.isList(id + ".text")) {
+                pages = config.getStringList(id + ".text");
+            } else {
+                pages = new ArrayList<>();
+                pages.add(config.getString(id + ".text", "No Text"));
+            }
+            
+            holograms.put(id, new NexusHologram(id, loc, pages));
+        }
+    }
+
+    @EventHandler
+    public void onInteract(PlayerInteractEntityEvent event) {
+        // Wir prüfen, ob auf ein Interaction-Entity geklickt wurde
+        for (NexusHologram holo : holograms.values()) {
+            if (holo.isInteractionEntity(event.getRightClicked().getUniqueId())) {
+                holo.nextPage(event.getPlayer());
+                break;
+            }
+        }
+    }
+
+    @EventHandler
+    public void onQuit(PlayerQuitEvent event) {
+        holograms.values().forEach(h -> h.removeForPlayer(event.getPlayer()));
+    }
+
+    @EventHandler
+    public void onWorldChange(PlayerChangedWorldEvent event) {
+        holograms.values().forEach(h -> h.removeForPlayer(event.getPlayer()));
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        // Cleanup alter Entities für den Joiner
+        Bukkit.getScheduler().runTaskLater(NexusLobby.getInstance(), () -> {
+            event.getPlayer().getWorld().getEntities().forEach(entity -> {
+                if (entity.getCustomName() != null && entity.getCustomName().startsWith("nexus_h_")) {
+                    if (!entity.getCustomName().endsWith("_" + event.getPlayer().getName())) {
+                        event.getPlayer().hideEntity(NexusLobby.getInstance(), entity);
+                    }
+                }
+            });
+        }, 5L);
+    }
+
+    public void createHologram(String id, Location loc, List<String> pages) {
+        config.set(id + ".world", loc.getWorld().getName());
+        config.set(id + ".x", loc.getX());
+        config.set(id + ".y", loc.getY());
+        config.set(id + ".z", loc.getZ());
+        config.set(id + ".text", pages);
+        try { config.save(file); } catch (IOException e) { e.printStackTrace(); }
+
+        NexusHologram holo = new NexusHologram(id, loc, pages);
+        holograms.put(id, holo);
+    }
+
+    public void removeHologram(String id) {
+        NexusHologram holo = holograms.remove(id);
+        if (holo != null) holo.removeAll();
+        config.set(id, null);
+        try { config.save(file); } catch (IOException e) { e.printStackTrace(); }
+    }
+
+    public Set<String> getHologramIds() { return config.getKeys(false); }
+
+    @Override
+    public void onDisable() {
+        holograms.values().forEach(NexusHologram::removeAll);
+        holograms.clear();
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/hologram/NexusHologram.java
+++ b/src/main/java/de/nexuslobby/modules/hologram/NexusHologram.java
@@ -0,0 +1,115 @@
+package de.nexuslobby.modules.hologram;
+
+import de.nexuslobby.NexusLobby;
+import me.clip.placeholderapi.PlaceholderAPI;
+import org.bukkit.Bukkit;
+import org.bukkit.Color;
+import org.bukkit.Location;
+import org.bukkit.entity.Display;
+import org.bukkit.entity.Interaction;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.TextDisplay;
+
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class NexusHologram {
+
+    private final String id;
+    private final Location location;
+    private final List<String> pages;
+    
+    private final Map<UUID, TextDisplay> playerEntities = new ConcurrentHashMap<>();
+    private final Map<UUID, Interaction> playerInteractions = new ConcurrentHashMap<>();
+    private final Map<UUID, Integer> currentPage = new ConcurrentHashMap<>();
+
+    public NexusHologram(String id, Location location, List<String> pages) {
+        this.id = id;
+        this.location = location;
+        this.pages = pages;
+    }
+
+    public void nextPage(Player player) {
+        if (pages.size() <= 1) return;
+        int next = (currentPage.getOrDefault(player.getUniqueId(), 0) + 1) % pages.size();
+        currentPage.put(player.getUniqueId(), next);
+        renderForPlayer(player);
+    }
+
+    public void renderForPlayer(Player player) {
+        if (!player.getWorld().equals(location.getWorld()) || player.getLocation().distanceSquared(location) > 2304) {
+            removeForPlayer(player);
+            return;
+        }
+
+        int pageIdx = currentPage.getOrDefault(player.getUniqueId(), 0);
+        String rawText = pages.get(pageIdx);
+
+        if (Bukkit.getPluginManager().isPluginEnabled("PlaceholderAPI")) {
+            rawText = PlaceholderAPI.setPlaceholders(player, rawText);
+        }
+        final String finalText = rawText.replace("&", "§").replace("\\n", "\n");
+
+        TextDisplay display = playerEntities.get(player.getUniqueId());
+
+        if (display == null || !display.isValid()) {
+            // Text erstellen
+            display = location.getWorld().spawn(location, TextDisplay.class, entity -> {
+                entity.setCustomName("nexus_h_" + id + "_" + player.getName());
+                entity.setCustomNameVisible(false);
+                entity.setPersistent(false);
+                entity.setBillboard(Display.Billboard.CENTER);
+                entity.setBackgroundColor(Color.fromARGB(0, 0, 0, 0));
+                entity.setText(finalText);
+                entity.setInvulnerable(true);
+            });
+
+            // Interaction Entity für Klick-Erkennung (Hitbox)
+            Interaction interact = location.getWorld().spawn(location, Interaction.class, entity -> {
+                entity.setInteractionWidth(2.0f);
+                entity.setInteractionHeight(2.0f);
+                entity.setPersistent(false);
+            });
+
+            final TextDisplay finalDisplay = display;
+            final Interaction finalInteract = interact;
+
+            for (Player other : Bukkit.getOnlinePlayers()) {
+                if (!other.equals(player)) {
+                    other.hideEntity(NexusLobby.getInstance(), finalDisplay);
+                    other.hideEntity(NexusLobby.getInstance(), finalInteract);
+                }
+            }
+
+            playerEntities.put(player.getUniqueId(), display);
+            playerInteractions.put(player.getUniqueId(), interact);
+        } else {
+            if (!display.getText().equals(finalText)) {
+                display.setText(finalText);
+            }
+        }
+    }
+
+    public void removeForPlayer(Player player) {
+        TextDisplay display = playerEntities.remove(player.getUniqueId());
+        if (display != null) display.remove();
+        
+        Interaction interact = playerInteractions.remove(player.getUniqueId());
+        if (interact != null) interact.remove();
+    }
+
+    public void removeAll() {
+        playerEntities.values().forEach(TextDisplay::remove);
+        playerInteractions.values().forEach(Interaction::remove);
+        playerEntities.clear();
+        playerInteractions.clear();
+    }
+
+    public boolean isInteractionEntity(UUID entityId) {
+        return playerInteractions.values().stream().anyMatch(i -> i.getUniqueId().equals(entityId));
+    }
+
+    public String getId() { return id; }
+}
--- a/src/main/java/de/nexuslobby/modules/intro/IntroModule.java
+++ b/src/main/java/de/nexuslobby/modules/intro/IntroModule.java
@@ -0,0 +1,219 @@
+package de.nexuslobby.modules.intro;
+
+import de.nexuslobby.NexusLobby;
+import de.nexuslobby.api.Module;
+import net.md_5.bungee.api.ChatMessageType;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerToggleSneakEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.*;
+
+public class IntroModule implements Module, Listener, CommandExecutor {
+
+    private final Set<UUID> activeIntro = new HashSet<>();
+    private final List<Location> points = new ArrayList<>();
+    private File configFile;
+    private FileConfiguration config;
+
+    // --- Einstellungen ---
+    private final int TICKS_FLUG = 70;   // Dauer der Fahrt zwischen zwei Punkten (3.5 Sek)
+    private final int TICKS_PAUSE = 30;  // Standzeit an jedem Punkt (1.5 Sek)
+
+    @Override
+    public String getName() { return "Intro"; }
+
+    @Override
+    public void onEnable() {
+        Bukkit.getPluginManager().registerEvents(this, NexusLobby.getInstance());
+        if (NexusLobby.getInstance().getCommand("intro") != null) {
+            NexusLobby.getInstance().getCommand("intro").setExecutor(this);
+        }
+        loadPoints();
+    }
+
+    @Override
+    public void onDisable() {
+        activeIntro.clear();
+    }
+
+    private void loadPoints() {
+        points.clear();
+        configFile = new File(NexusLobby.getInstance().getDataFolder(), "intro.yml");
+        if (!configFile.exists()) {
+            try { configFile.createNewFile(); } catch (IOException ignored) {}
+        }
+        config = YamlConfiguration.loadConfiguration(configFile);
+        List<?> list = config.getList("points");
+        if (list != null) {
+            for (Object obj : list) {
+                if (obj instanceof Location loc) points.add(loc);
+            }
+        }
+    }
+
+    private void savePoints() {
+        config.set("points", points);
+        try { config.save(configFile); } catch (IOException e) { e.printStackTrace(); }
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) {
+        if (!event.getPlayer().hasPlayedBefore() && points.size() >= 2) {
+            startIntro(event.getPlayer());
+        }
+    }
+
+    @EventHandler
+    public void onSneak(PlayerToggleSneakEvent event) {
+        if (activeIntro.contains(event.getPlayer().getUniqueId()) && event.isSneaking()) {
+            stopIntro(event.getPlayer(), true);
+        }
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
+        if (!(sender instanceof Player p)) return true;
+        if (!p.hasPermission("nexuslobby.admin")) return true;
+
+        if (args.length == 0) {
+            p.sendMessage("§8§m------------------------------------");
+            p.sendMessage("§6§lNexus Intro System (Cinematic)");
+            p.sendMessage("§e/intro add §7- Punkt hinzufügen");
+            p.sendMessage("§e/intro clear §7- Alle Punkte löschen");
+            p.sendMessage("§e/intro start §7- Teste die Fahrt");
+            p.sendMessage("§8§m------------------------------------");
+            return true;
+        }
+
+        switch (args[0].toLowerCase()) {
+            case "add" -> {
+                points.add(p.getLocation());
+                savePoints();
+                p.sendMessage("§8[§6Nexus§8] §aPunkt #" + points.size() + " wurde gesetzt!");
+            }
+            case "clear" -> {
+                points.clear();
+                savePoints();
+                p.sendMessage("§8[§6Nexus§8] §cAlle Intro-Punkte wurden gelöscht.");
+            }
+            case "start" -> {
+                if (points.size() < 2) {
+                    p.sendMessage("§8[§6Nexus§8] §cDu brauchst mindestens 2 Punkte für eine Fahrt.");
+                } else {
+                    startIntro(p);
+                }
+            }
+        }
+        return true;
+    }
+
+    public void startIntro(Player player) {
+        activeIntro.add(player.getUniqueId());
+        player.setGameMode(GameMode.SPECTATOR);
+
+        new BukkitRunnable() {
+            int currentSegment = 0;
+            int tickInSegment = 0;
+            boolean isPausing = true;
+
+            @Override
+            public void run() {
+                try {
+                    if (!player.isOnline() || !activeIntro.contains(player.getUniqueId())) {
+                        this.cancel();
+                        return;
+                    }
+
+                    if (currentSegment >= points.size() - 1) {
+                        stopIntro(player, false);
+                        this.cancel();
+                        return;
+                    }
+
+                    Location start = points.get(currentSegment);
+                    Location end = points.get(currentSegment + 1);
+
+                    if (isPausing) {
+                        // Kamera steht am aktuellen Punkt
+                        player.teleport(start);
+                        tickInSegment++;
+                        if (tickInSegment >= TICKS_PAUSE) {
+                            isPausing = false;
+                            tickInSegment = 0;
+                        }
+                    } else {
+                        // Kamera fliegt zum nächsten Punkt
+                        double progress = (double) tickInSegment / (double) TICKS_FLUG;
+                        
+                        // "Smooth Step" für flüssigeres Beschleunigen/Bremsen
+                        double smoothT = progress * progress * (3 - 2 * progress);
+                        
+                        Location nextLoc = interpolate(start, end, smoothT);
+                        player.teleport(nextLoc);
+
+                        tickInSegment++;
+                        if (tickInSegment >= TICKS_FLUG) {
+                            isPausing = true;
+                            tickInSegment = 0;
+                            currentSegment++;
+                        }
+                    }
+
+                    player.spigot().sendMessage(ChatMessageType.ACTION_BAR, 
+                        new TextComponent("§6§lINTRO-TOUR §8| §ePunkt " + (currentSegment + 1) + " §8| §7Sneak zum Abbrechen"));
+
+                } catch (Exception e) {
+                    this.cancel();
+                    stopIntro(player, true);
+                }
+            }
+        }.runTaskTimer(NexusLobby.getInstance(), 0L, 1L);
+    }
+
+    private Location interpolate(Location start, Location end, double t) {
+        double x = start.getX() + (end.getX() - start.getX()) * t;
+        double y = start.getY() + (end.getY() - start.getY()) * t;
+        double z = start.getZ() + (end.getZ() - start.getZ()) * t;
+        
+        // Sanfte Drehung
+        float startYaw = start.getYaw();
+        float endYaw = end.getYaw();
+        // Verhindert ruckartige 360-Grad Dreher
+        float diff = (endYaw - startYaw) % 360;
+        if (diff > 180) diff -= 360;
+        if (diff < -180) diff += 360;
+        float yaw = startYaw + diff * (float)t;
+
+        float pitch = (float) (start.getPitch() + (end.getPitch() - start.getPitch()) * t);
+
+        return new Location(start.getWorld(), x, y, z, yaw, pitch);
+    }
+
+    private void stopIntro(Player player, boolean canceled) {
+        activeIntro.remove(player.getUniqueId());
+        player.setGameMode(GameMode.ADVENTURE);
+        player.teleport(player.getWorld().getSpawnLocation());
+        
+        if (canceled) {
+            player.sendMessage("§8[§6Nexus§8] §cIntro abgebrochen.");
+        } else {
+            player.sendMessage("§8[§6Nexus§8] §aWillkommen auf dem Netzwerk!");
+        }
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/mapart/MapArtModule.java
+++ b/src/main/java/de/nexuslobby/modules/mapart/MapArtModule.java
@@ -0,0 +1,298 @@
+package de.nexuslobby.modules.mapart;
+
+import de.nexuslobby.NexusLobby;
+import de.nexuslobby.api.Module;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.ItemFrame;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.MapMeta;
+import org.bukkit.map.MapCanvas;
+import org.bukkit.map.MapRenderer;
+import org.bukkit.map.MapView;
+import org.bukkit.util.RayTraceResult;
+import org.jetbrains.annotations.NotNull;
+
+import javax.imageio.ImageIO;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class MapArtModule implements Module, CommandExecutor {
+
+    private File storageFile;
+    private FileConfiguration storageConfig;
+    
+    // RAM-Schutz: Cache für bereits geladene Bild-Kacheln
+    private final Map<String, BufferedImage> tileCache = new ConcurrentHashMap<>();
+    // Hilfs-Set um parallele Downloads der gleichen URL zu verhindern
+    private final Map<String, Boolean> loadingShield = new ConcurrentHashMap<>();
+
+    @Override
+    public String getName() { return "MapArt"; }
+
+    @Override
+    public void onEnable() {
+        if (NexusLobby.getInstance().getCommand("mapart") != null) {
+            NexusLobby.getInstance().getCommand("mapart").setExecutor(this);
+        }
+        initStorage();
+        reloadMaps();
+    }
+
+    @Override
+    public void onDisable() {
+        saveStorage();
+        tileCache.clear();
+    }
+
+    private void initStorage() {
+        storageFile = new File(NexusLobby.getInstance().getDataFolder(), "mapart.yml");
+        if (!storageFile.exists()) {
+            try {
+                storageFile.createNewFile();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        storageConfig = YamlConfiguration.loadConfiguration(storageFile);
+    }
+
+    private void saveStorage() {
+        try {
+            storageConfig.save(storageFile);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void reloadMaps() {
+        ConfigurationSection section = storageConfig.getConfigurationSection("active_maps");
+        if (section == null) return;
+
+        for (String idStr : section.getKeys(false)) {
+            try {
+                int mapId = Integer.parseInt(idStr);
+                String url = section.getString(idStr + ".url");
+                int x = section.getInt(idStr + ".x");
+                int y = section.getInt(idStr + ".y");
+                int totalW = section.getInt(idStr + ".totalW");
+                int totalH = section.getInt(idStr + ".totalH");
+
+                @SuppressWarnings("deprecation")
+                MapView view = Bukkit.getMap(mapId);
+                if (view != null) {
+                    applyRenderer(view, url, x, y, totalW, totalH);
+                }
+            } catch (Exception ignored) {}
+        }
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
+        if (!(sender instanceof Player player)) return true;
+        if (!player.hasPermission("nexuslobby.mapart")) {
+            player.sendMessage("§8[§6Nexus§8] §cKeine Rechte.");
+            return true;
+        }
+
+        if (args.length == 0) {
+            sendHelp(player);
+            return true;
+        }
+
+        if (args[0].equalsIgnoreCase("delete")) {
+            int radius = 3;
+            if (args.length == 2) {
+                try {
+                    radius = Integer.parseInt(args[1]);
+                } catch (NumberFormatException e) {
+                    player.sendMessage("§8[§6Nexus§8] §cUngültiger Radius.");
+                    return true;
+                }
+            }
+            deleteNearbyMaps(player, radius);
+            return true;
+        }
+
+        if (args.length != 2) {
+            sendHelp(player);
+            return true;
+        }
+
+        RayTraceResult rayTrace = player.rayTraceBlocks(5);
+        if (rayTrace == null || rayTrace.getHitBlock() == null || rayTrace.getHitBlockFace() == null) {
+            player.sendMessage("§8[§6Nexus§8] §cBitte schaue eine Wand direkt an.");
+            return true;
+        }
+
+        Block targetBlock = rayTrace.getHitBlock();
+        BlockFace hitFace = rayTrace.getHitBlockFace();
+
+        if (hitFace == BlockFace.UP || hitFace == BlockFace.DOWN) {
+            player.sendMessage("§8[§6Nexus§8] §cAktuell nur an vertikalen Wänden möglich.");
+            return true;
+        }
+
+        String url = args[0];
+        int width, height;
+        try {
+            String[] parts = args[1].toLowerCase().split("x");
+            width = Integer.parseInt(parts[0]);
+            height = Integer.parseInt(parts[1]);
+        } catch (Exception e) {
+            player.sendMessage("§8[§6Nexus§8] §cUngültiges Format (z.B. 6x4).");
+            return true;
+        }
+
+        player.sendMessage("§8[§6Nexus§8] §7Bild wird verarbeitet...");
+        createRaster(player, targetBlock, hitFace, url, width, height);
+
+        return true;
+    }
+
+    private void sendHelp(Player p) {
+        p.sendMessage("§8§m------------------------------------");
+        p.sendMessage("§6§lNexus MapArt");
+        p.sendMessage("§e/mapart <URL> <BxH> §7- Bild erstellen");
+        p.sendMessage("§e/mapart delete [Radius] §7- Bilder in der Nähe löschen");
+        p.sendMessage("§8§m------------------------------------");
+    }
+
+    private void deleteNearbyMaps(Player player, int radius) {
+        AtomicInteger count = new AtomicInteger(0);
+        player.getNearbyEntities(radius, radius, radius).forEach(entity -> {
+            if (entity instanceof ItemFrame frame) {
+                ItemStack item = frame.getItem();
+                if (item != null && item.getType() == Material.FILLED_MAP && item.getItemMeta() instanceof MapMeta meta) {
+                    if (meta.hasMapView()) {
+                        int id = meta.getMapView().getId();
+                        if (storageConfig.contains("active_maps." + id)) {
+                            storageConfig.set("active_maps." + id, null);
+                            frame.remove();
+                            count.incrementAndGet();
+                        }
+                    }
+                }
+            }
+        });
+        saveStorage();
+        player.sendMessage("§8[§6Nexus§8] §aErfolgreich §e" + count.get() + " §aKartenelemente gelöscht.");
+    }
+
+    private void createRaster(Player player, Block startBlock, BlockFace face, String url, int gridW, int gridH) {
+        BlockFace rightDirection;
+        switch (face) {
+            case NORTH: rightDirection = BlockFace.WEST; break;
+            case SOUTH: rightDirection = BlockFace.EAST; break;
+            case EAST:  rightDirection = BlockFace.NORTH; break;
+            case WEST:  rightDirection = BlockFace.SOUTH; break;
+            default:    rightDirection = BlockFace.EAST;
+        }
+
+        Block origin = startBlock.getRelative(face);
+
+        for (int y = 0; y < gridH; y++) {
+            for (int x = 0; x < gridW; x++) {
+                Block currentPos = origin.getRelative(rightDirection, x).getRelative(BlockFace.DOWN, y);
+                spawnPersistentFrame(player, currentPos, face, url, x, y, gridW, gridH);
+            }
+        }
+        player.sendMessage("§8[§6Nexus§8] §aBild-Raster wurde permanent platziert!");
+    }
+
+    private void spawnPersistentFrame(Player player, Block pos, BlockFace face, String url, int x, int y, int totalW, int totalH) {
+        MapView view = Bukkit.createMap(player.getWorld());
+        applyRenderer(view, url, x, y, totalW, totalH);
+
+        String path = "active_maps." + view.getId();
+        storageConfig.set(path + ".url", url);
+        storageConfig.set(path + ".x", x);
+        storageConfig.set(path + ".y", y);
+        storageConfig.set(path + ".totalW", totalW);
+        storageConfig.set(path + ".totalH", totalH);
+        saveStorage();
+
+        ItemStack mapStack = new ItemStack(Material.FILLED_MAP);
+        MapMeta meta = (MapMeta) mapStack.getItemMeta();
+        if (meta != null) {
+            meta.setMapView(view);
+            mapStack.setItemMeta(meta);
+        }
+
+        try {
+            ItemFrame frame = player.getWorld().spawn(pos.getLocation(), ItemFrame.class);
+            frame.setFacingDirection(face);
+            frame.setItem(mapStack);
+            frame.setVisible(false);
+            frame.setFixed(true);
+        } catch (Exception ignored) {}
+    }
+
+    private void applyRenderer(MapView view, String url, int tileX, int tileY, int totalW, int totalH) {
+        view.getRenderers().forEach(view::removeRenderer);
+        view.addRenderer(new MapRenderer() {
+            private final String cacheKey = url + "_" + totalW + "x" + totalH + "_" + tileX + "_" + tileY;
+            private boolean errorLogged = false;
+
+            @Override
+            public void render(@NotNull MapView map, @NotNull MapCanvas canvas, @NotNull Player p) {
+                // 1. Wenn Kachel im Cache, sofort zeichnen (extrem schnell)
+                if (tileCache.containsKey(cacheKey)) {
+                    canvas.drawImage(0, 0, tileCache.get(cacheKey));
+                    return;
+                }
+
+                // 2. Wenn bereits ein Thread für diese URL lädt, abbrechen (verhindert Spam)
+                if (loadingShield.containsKey(url)) return;
+
+                // 3. Bild asynchron laden
+                loadingShield.put(url, true);
+                Bukkit.getScheduler().runTaskAsynchronously(NexusLobby.getInstance(), () -> {
+                    try {
+                        BufferedImage original = ImageIO.read(new URL(url));
+                        if (original != null) {
+                            int targetW = totalW * 128;
+                            int targetH = totalH * 128;
+
+                            BufferedImage fullScaled = new BufferedImage(targetW, targetH, BufferedImage.TYPE_INT_ARGB);
+                            Graphics2D g = fullScaled.createGraphics();
+                            g.drawImage(original.getScaledInstance(targetW, targetH, Image.SCALE_SMOOTH), 0, 0, null);
+                            g.dispose();
+
+                            // Alle benötigten Kacheln für dieses Bild in den Cache legen
+                            for (int ty = 0; ty < totalH; ty++) {
+                                for (int tx = 0; tx < totalW; tx++) {
+                                    String key = url + "_" + totalW + "x" + totalH + "_" + tx + "_" + ty;
+                                    tileCache.put(key, fullScaled.getSubimage(tx * 128, ty * 128, 128, 128));
+                                }
+                            }
+                        }
+                    } catch (Exception e) {
+                        if (!errorLogged) {
+                            NexusLobby.getInstance().getLogger().warning("Fehler beim Laden von MapArt: " + url);
+                            errorLogged = true;
+                        }
+                    } finally {
+                        loadingShield.remove(url);
+                    }
+                });
+            }
+        });
+    }
+}
--- a/src/main/java/de/nexuslobby/modules/tablist/TablistModule.java
+++ b/src/main/java/de/nexuslobby/modules/tablist/TablistModule.java
@@ -1,210 +1,311 @@
 package de.nexuslobby.modules.tablist;

+
+
 import de.nexuslobby.NexusLobby;
+
 import de.nexuslobby.api.Module;
+
 import net.luckperms.api.LuckPerms;
+
 import net.luckperms.api.LuckPermsProvider;
-import net.luckperms.api.model.group.Group;
+
 import net.luckperms.api.model.user.User;
+
 import me.clip.placeholderapi.PlaceholderAPI;
+
 import org.bukkit.Bukkit;
+
 import org.bukkit.configuration.file.FileConfiguration;
+
 import org.bukkit.entity.Player;
+
 import org.bukkit.scheduler.BukkitTask;
+
 import org.bukkit.scoreboard.Scoreboard;
+
 import org.bukkit.scoreboard.Team;

-import java.util.HashMap;
+
+
 import java.util.List;
-import java.util.Map;
+
+

 public class TablistModule implements Module {

+
+
    private BukkitTask refreshTask;
+
    private int currentHeaderIndex = 0;
+
    private int currentFooterIndex = 0;
+
    private LuckPerms luckPerms;
+
    private boolean placeholderAPIEnabled;

-    // Pixel-Breiten Tabelle für die Standard Minecraft Schriftart
-    private static final Map<Character, Integer> CHAR_WIDTHS = new HashMap<>();
-    private static final int TARGET_PIXEL_WIDTH = 90; // Ziel-Breite für den Namensteil vor dem Ping

-    static {
-        String chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-        for (char c : chars.toCharArray()) CHAR_WIDTHS.put(c, 6);
-        CHAR_WIDTHS.put('i', 2); CHAR_WIDTHS.put('l', 3); CHAR_WIDTHS.put('t', 4);
-        CHAR_WIDTHS.put('I', 4); CHAR_WIDTHS.put('f', 5); CHAR_WIDTHS.put('k', 5);
-        CHAR_WIDTHS.put('.', 2); CHAR_WIDTHS.put(',', 2); CHAR_WIDTHS.put('!', 2);
-        CHAR_WIDTHS.put('(', 5); CHAR_WIDTHS.put(')', 5); CHAR_WIDTHS.put('[', 4);
-        CHAR_WIDTHS.put(']', 4); CHAR_WIDTHS.put('{', 5); CHAR_WIDTHS.put('}', 5);
-        CHAR_WIDTHS.put('|', 2); CHAR_WIDTHS.put('*', 5); CHAR_WIDTHS.put(' ', 4);
-        CHAR_WIDTHS.put('_', 6);
-    }

    @Override
+
    public String getName() { return "Tablist"; }

+
+
    @Override
+
    public void onEnable() {
+
        FileConfiguration vConfig = NexusLobby.getInstance().getVisualsConfig();
+
        if (!vConfig.getBoolean("tablist.enabled", true)) return;

+
+
        if (Bukkit.getPluginManager().getPlugin("LuckPerms") != null) luckPerms = LuckPermsProvider.get();
+
        placeholderAPIEnabled = Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null;

+
+
+        // Nutzt jetzt das Intervall aus der visuals.yml
+
        long interval = vConfig.getLong("tablist.interval-ticks", 40L);
+
        refreshTask = Bukkit.getScheduler().runTaskTimer(NexusLobby.getInstance(), this::refreshAll, 10L, interval);
+
    }

+
+
    private void refreshAll() {
+
        updateAnimationIndices();
+
        for (Player viewer : Bukkit.getOnlinePlayers()) {
+
            viewer.setPlayerListHeader(getHeader(viewer));
+
            viewer.setPlayerListFooter(getFooter(viewer));
-            updateTeamsAndFormatting(viewer);
+
+            updateTeams(viewer);
+
        }
+
    }

-    private void updateTeamsAndFormatting(Player viewer) {
+
+
+    private void updateTeams(Player viewer) {
+
        FileConfiguration vConfig = NexusLobby.getInstance().getVisualsConfig();
-        boolean showPrefix = vConfig.getBoolean("tablist.show-prefix-in-playerlist", true);
+
+        if (!vConfig.getBoolean("tablist.show-prefix-in-playerlist", true)) return;
+
+

        Scoreboard sb = viewer.getScoreboard();
+
        if (sb == Bukkit.getScoreboardManager().getMainScoreboard()) return;

+
+
        for (Player target : Bukkit.getOnlinePlayers()) {
-            String sortPriority = getSortPriority(target);
-            String teamName = sortPriority + target.getName();
-            
+
+            String teamName = "tab_" + target.getName();
+
            if (teamName.length() > 16) teamName = teamName.substring(0, 16);

+
+
            Team team = sb.getTeam(teamName);
+
            if (team == null) team = sb.registerNewTeam(teamName);

-            String prefix = showPrefix ? getPlayerPrefix(target) : "§7";
+
+
+            String prefix = getPlayerPrefix(target);
+
+            String suffix = getPlayerSuffix(target);
+
+
+
            if (!team.getPrefix().equals(prefix)) team.setPrefix(prefix);

-            // Hier wird der Pixel-Ausgleich berechnet, damit der Trenner | immer an der gleichen Stelle ist
-            String pingSuffix = getAlignedPingSuffix(target.getName(), target.getPing());
-            if (!team.getSuffix().equals(pingSuffix)) team.setSuffix(pingSuffix);
-            
+            if (!team.getSuffix().equals(suffix)) team.setSuffix(suffix);
+
+           
+
            if (!team.hasEntry(target.getName())) {
+
                team.addEntry(target.getName());
-            }
-            
-            // Setzt den Listnamen zurück, damit Team-Prefix/Suffix greifen
-            if (target.getPlayerListName() != null) {
-                target.setPlayerListName(null);
-            }
-        }
-    }

-    private String getAlignedPingSuffix(String name, int ping) {
-        int currentWidth = 0;
-        for (char c : name.toCharArray()) {
-            currentWidth += CHAR_WIDTHS.getOrDefault(c, 6);
+            }
+
        }

-        int diff = TARGET_PIXEL_WIDTH - currentWidth;
-        StringBuilder spacer = new StringBuilder(" "); 
-
-        // Ausgleich mit fetten (5px) und normalen (4px) Leerzeichen für maximale Präzision
-        while (diff > 0) {
-            if (diff >= 5) {
-                spacer.append("§l "); 
-                diff -= 5;
-            } else {
-                spacer.append(" "); 
-                diff -= 4;
-            }
-        }
-
-        String pingColor = (ping < 50) ? "§a" : (ping < 100 ? "§e" : "§c");
-        // §r bricht das fettgedruckte Leerzeichen ab, damit der Ping normal aussieht
-        return "§r" + spacer.toString() + "§8| " + pingColor + ping + "ms";
    }

-    private String getSortPriority(Player player) {
-        if (luckPerms == null) return "z_"; 
-        User user = luckPerms.getUserManager().getUser(player.getUniqueId());
-        if (user == null) return "z_";
-        Group group = luckPerms.getGroupManager().getGroup(user.getPrimaryGroup());
-        if (group == null) return "z_";
-        int weight = group.getWeight().orElse(0);
-        int invertedWeight = 1000 - weight;
-        return String.format("%03d", invertedWeight) + "_";
-    }
+

    private String getPlayerPrefix(Player player) {
+
        String prefix = "";
+
        if (luckPerms != null) {
+
            User user = luckPerms.getUserManager().getUser(player.getUniqueId());
+
            if (user != null && user.getCachedData().getMetaData().getPrefix() != null) {
+
                prefix = user.getCachedData().getMetaData().getPrefix();
+
            }
+
        }
+
        if (prefix.isEmpty() && placeholderAPIEnabled) {
+
            prefix = PlaceholderAPI.setPlaceholders(player, "%luckperms_prefix%");
+
        }
+
        return colorize(prefix.isEmpty() ? "&7" : prefix + " ");
+
    }

+
+
+    private String getPlayerSuffix(Player player) {
+
+        // Hier könnte man später auch Suffixe aus der Config laden
+
+        return colorize(" &8[&a" + player.getPing() + "ms&8]");
+
+    }
+
+
+
    private void updateAnimationIndices() {
+
        FileConfiguration vConfig = NexusLobby.getInstance().getVisualsConfig();
+
        List<String> h = vConfig.getStringList("tablist.header-animations");
+
        List<String> f = vConfig.getStringList("tablist.footer-animations");
+
        if (!h.isEmpty()) currentHeaderIndex = (currentHeaderIndex + 1) % h.size();
+
        if (!f.isEmpty()) currentFooterIndex = (currentFooterIndex + 1) % f.size();
+
    }

+
+
    private String getHeader(Player p) {
+
        FileConfiguration vConfig = NexusLobby.getInstance().getVisualsConfig();
+
        List<String> list = vConfig.getStringList("tablist.header-animations");
+
        if (list.isEmpty()) return "§6NexusLobby";
+
        return replacePlaceholders(list.get(currentHeaderIndex), p);
+
    }

+
+
    private String getFooter(Player p) {
+
        FileConfiguration vConfig = NexusLobby.getInstance().getVisualsConfig();
+
        List<String> list = vConfig.getStringList("tablist.footer-animations");
+
        if (list.isEmpty()) return "§7Willkommen";
+
        return replacePlaceholders(list.get(currentFooterIndex), p);
+
    }

+
+
    private String replacePlaceholders(String text, Player p) {
+
        FileConfiguration vConfig = NexusLobby.getInstance().getVisualsConfig();
+
+       
+
        text = text.replace("{server}", vConfig.getString("tablist.server-name", "NexusLobby"));
+
        text = text.replace("{player}", p.getName());
+
        text = text.replace("{online}", String.valueOf(Bukkit.getOnlinePlayers().size()));
+
        text = text.replace("{staff}", String.valueOf(getOnlineStaffCount()));
+
        text = text.replace("{separator}", vConfig.getString("tablist.separator-line", ""));
+
+
+
        text = text.replace("{website}", vConfig.getBoolean("tablist.show-website") ? vConfig.getString("tablist.website", "") : "");
+
        text = text.replace("{teamspeak}", vConfig.getBoolean("tablist.show-teamspeak") ? vConfig.getString("tablist.teamspeak-address", "") : "");
+
        text = text.replace("{discord}", vConfig.getBoolean("tablist.show-discord") ? vConfig.getString("tablist.discord-address", "") : "");

+
+
        if (placeholderAPIEnabled) {
+
            text = PlaceholderAPI.setPlaceholders(p, text);
+
        }
+
+
+
        return colorize(text);
+
    }

+
+
    private int getOnlineStaffCount() {
+
        FileConfiguration vConfig = NexusLobby.getInstance().getVisualsConfig();
+
        String permission = vConfig.getString("tablist.staff-permission", "nexuslobby.staff");
+
        int count = 0;
+
        for (Player p : Bukkit.getOnlinePlayers()) {
+
            if (p.hasPermission(permission)) count++;
+
        }
+
        return count;
+
    }

+
+
    private String colorize(String s) {
+
        return s == null ? "" : s.replace("&", "§");
+
    }

-    @Override 
-    public void onDisable() { 
-        if (refreshTask != null) refreshTask.cancel(); 
+
+
+    @Override
+
+    public void onDisable() {
+
+        if (refreshTask != null) refreshTask.cancel();
+
    }
+
 }
--- a/src/main/resources/config.yml
+++ b/src/main/resources/config.yml
@@ -36,11 +36,11 @@ items:
    build-toggle:
      enabled: true
      displayname: "&aBaumodus"
-      slot: 1
+      slot: 0
    gadget:
-      enabled: true
+      enabled: false
      displayname: "&bGadgets"
-      slot: 2
+      slot: 8

 # --- Portal Einstellungen ---
 portals:
--- a/src/main/resources/plugin.yml
+++ b/src/main/resources/plugin.yml
@@ -1,6 +1,6 @@
 name: NexusLobby
 main: de.nexuslobby.NexusLobby
-version: "1.0.1"
+version: "1.0.4"
 api-version: "1.21"
 author: M_Viper
 description: Modular Lobby Plugin
@@ -12,49 +12,53 @@ commands:
    usage: /portal <args>
    permission: nexuslobby.portal
    permission-message: "§cKeine Rechte!"
-
  giveportalwand:
    description: Gibt das Portal-Werkzeug
    usage: /giveportalwand
    permission: nexuslobby.portal.give
    permission-message: "§cDu hast keine Berechtigung dafür."
-
  maintenance:
    description: Aktiviert oder deaktiviert den Wartungsmodus
    usage: /maintenance <on|off>
    permission: nexuslobby.maintenance
    permission-message: "§cDu hast keine Rechte!"
-
  serverswitcher:
    description: Öffnet die Server Switcher GUI
    usage: /serverswitcher
    permission: nexuslobby.serverswitcher
    permission-message: "§cDu hast keine Rechte!"
-
  settings:
    description: Öffnet das Lobby-Einstellungsmenü (Gamerules)
    usage: /settings
    permission: nexuslobby.admin
    permission-message: "§cDu hast keine Rechte für die Admin-Einstellungen!"
-
  build:
    description: Aktiviert oder deaktiviert den Baumodus
    usage: /build
    permission: nexuslobby.build
    permission-message: "§cDu hast keine Rechte!"
-
  nexuslobby:
    description: Zeigt Informationen über das Plugin an oder lädt es neu
    usage: /nexuslobby [reload]
    aliases: [nexus]
-
-  # --- ArmorStandTools Sektion ---
  nexustools:
    description: Nexus ArmorStand Editor
    aliases: [nt, ntools, astools]
  nexuscmd:
    description: Nexus Command Binder
    aliases: [ncmd, ascmd]
+  holo:
+    description: Verwalte Lobby Hologramme (Text-Displays)
+    usage: /holo <create|delete> <id> [text]
+    permission: nexuslobby.hologram
+  mapart:
+    description: Erstellt ein Bild-Raster auf unsichtbaren Rahmen
+    usage: /mapart <URL> <BxH>
+    permission: nexuslobby.mapart
+  intro:
+    description: Verwalte und teste die Cinematic Intro Tour
+    usage: /intro <add|clear|start>
+    permission: nexuslobby.admin

 permissions:
  nexuslobby.portal:
@@ -70,7 +74,7 @@ permissions:
    description: Zugriff auf den Server Switcher
    default: true
  nexuslobby.admin:
-    description: Voller Zugriff auf Lobby-Gamerules, Einstellungen und Reload
+    description: Voller Zugriff auf Lobby-Gamerules, Einstellungen, Intro und Reload
    default: op
  nexuslobby.build:
    description: Erlaubt das Umgehen des Lobby-Schutzes zum Bauen
@@ -80,4 +84,13 @@ permissions:
    default: op
  nexuslobby.armorstand.cmd:
    description: Erlaubt das Binden von Commands via NexusCmd
+    default: op
+  nexuslobby.armorstand.dynamic:
+    description: Erlaubt das Markieren von dynamischen NPCs
+    default: op
+  nexuslobby.hologram:
+    description: Erlaubt das Erstellen von Text-Display Hologrammen
+    default: op
+  nexuslobby.mapart:
+    description: Erlaubt das Erstellen von Map-Art Bildern
    default: op
Author	SHA1	Message	Date
M_Viper	fa6c79aa53	README.md aktualisiert	2026-01-23 11:40:28 +00:00
M_Viper	27b9563a45	Update from Git Manager GUI	2026-01-23 12:17:49 +01:00
M_Viper	96973d44e5	Upload pom.xml via GUI	2026-01-23 11:17:49 +00:00
M_Viper	6630621ba1	Upload pom.xml via GUI	2026-01-23 09:43:54 +00:00
M_Viper	5f2c05d85e	Update from Git Manager GUI	2026-01-23 10:43:53 +01:00
M_Viper	9fd0690ba8	Update from Git Manager GUI	2026-01-22 23:16:25 +01:00
M_Viper	233639dd52	Upload pom.xml via GUI	2026-01-22 22:16:25 +00:00