src/main/java/vpd/bowandaero12/furnacelv/items/LevelMenu.java gelöscht

pom.xml

@@ -6,14 +6,14 @@
 
     <groupId>vpd.bowandaero12</groupId>
     <artifactId>FurnaceLevels</artifactId>
-    <version>2.0</version>
+    <version>2.1</version>
     <packaging>jar</packaging>
 
     <name>FurnaceLevels</name>
     <description>Öfen werden bis Stufe 5 schneller!</description>
 
     <properties>
-        <java.version>17</java.version>
+        <java.version>21</java.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 
@@ -47,7 +47,7 @@
         <dependency>
             <groupId>com.comphenix.protocol</groupId>
             <artifactId>ProtocolLib</artifactId>
-            <version>5.2.0</version>
+            <version>5.4.0</version>
             <scope>system</scope>
             <systemPath>C:/Users/Viper/Desktop/ProtocolLib.jar</systemPath>
         </dependency>

src/main/java/vpd/bowandaero12/furnacelv/FurnaceLevels.java

@@ -2,76 +2,73 @@ package vpd.bowandaero12.furnacelv;
 
 import com.comphenix.protocol.ProtocolLibrary;
 import com.comphenix.protocol.ProtocolManager;
-import java.util.logging.Logger;
 import net.milkbowl.vault.economy.Economy;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.event.Listener;
-import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.PluginManager;
 import org.bukkit.plugin.RegisteredServiceProvider;
 import org.bukkit.plugin.java.JavaPlugin;
 import vpd.bowandaero12.furnacelv.commands.DebugCmd;
+import vpd.bowandaero12.furnacelv.commands.GiveCommand;
 import vpd.bowandaero12.furnacelv.events.FurnaceEvent;
-import vpd.bowandaero12.furnacelv.items.ItemHandler;
-import vpd.bowandaero12.furnacelv.items.LevelMenu;
 import vpd.bowandaero12.furnacelv.utils.Configs;
 
-public class FurnaceLevels extends JavaPlugin {
+public final class FurnaceLevels extends JavaPlugin {
-  private static final Logger log = Logger.getLogger("FurnaceLevels");
 
     public ProtocolManager protocolManager;
-  
     public Economy vaultEco;
-  
-  private final FurnaceEvent furnaceEvent = new FurnaceEvent(this);
-  
-  public final ItemHandler itemhandler = new ItemHandler(this);
-  
-  public final LevelMenu lvmenu = new LevelMenu(this);
-  
     public final Configs configs = new Configs(this);
     
-  public final DebugCmd debug = new DebugCmd(this);
+    // Speichere die Event-Listener-Instanz hier
+    private FurnaceEvent furnaceEventListener;
 
+    @Override
     public void onEnable() {
-    PluginManager pm = getServer().getPluginManager();
-    this.protocolManager = ProtocolLibrary.getProtocolManager();
         this.configs.createConfigs();
-    boolean useEco = true;
+
-    if (this.configs.getConfig().isSet("use-economy"))
+        if (getServer().getPluginManager().getPlugin("ProtocolLib") == null) {
-      useEco = this.configs.getConfig().getBoolean("use-economy"); 
+            getLogger().severe("ProtocolLib wurde nicht gefunden! Das Plugin wird deaktiviert.");
+            getServer().getPluginManager().disablePlugin(this);
+            return;
+        }
+        this.protocolManager = ProtocolLibrary.getProtocolManager();
+
+        boolean useEco = this.configs.getConfig().getBoolean("use-economy", true);
         if (useEco && setupEconomy()) {
-      log.info(String.format("[%s] " + this.vaultEco.getName() + " has been detected and is in use!", new Object[] { getDescription().getName() }));
+            getLogger().info(String.format("[%s] %s wurde erkannt und wird verwendet.", getDescription().getName(), this.vaultEco.getName()));
         } else {
-      log.info(String.format("[%s] Using custom items for furnace upgrades.", new Object[] { getDescription().getName() }));
+            getLogger().info(String.format("[%s] Verwendet benutzerdefinierte Items für Ofen-Upgrades.", getDescription().getName()));
-    } 
-    pm.registerEvents((Listener)this.furnaceEvent, (Plugin)this);
-    pm.registerEvents((Listener)this.itemhandler, (Plugin)this);
-    pm.registerEvents((Listener)this.lvmenu, (Plugin)this);
-    getCommand("fldebug").setExecutor((CommandExecutor)this.debug);
-    checkVer(getDescription().getVersion());
-    this.itemhandler.registerFurnaces();
-    this.furnaceEvent.setValues();
         }
 
-  public void onDisable() {}
+        PluginManager pm = getServer().getPluginManager();
 
-  private void checkVer(String ver) {
+        // Erstelle die Instanz und speichere sie
-    if (!this.configs.getConfig().isSet("version") || !this.configs.getConfig().getString("version").equals(ver)) {
+        this.furnaceEventListener = new FurnaceEvent(this);
-      log.warning(String.format("[%s] Your configuration file is outdated! Update it by renaming the new config file to config.yml and copying any changed settings.", new Object[] { getDescription().getName() }));
+
-      this.configs.createUpdatedConfig();
+        // Registriere die gespeicherte Instanz
-    } 
+        pm.registerEvents(this.furnaceEventListener, this);
-    if (!this.configs.getLang().isSet("version") || !this.configs.getLang().getString("version").equals(ver)) {
+
-      log.warning(String.format("[%s] Your lang.yml file is outdated! Update it by renaming the new lang file to lang.yml and copying any changed settings.", new Object[] { getDescription().getName() }));
+        getCommand("fldebug").setExecutor(new DebugCmd(this));
-      this.configs.createUpdatedLang();
+        getCommand("flgive").setExecutor(new GiveCommand(this));
+
+        // Rufe setValues() auf der korrekten, gespeicherten Instanz auf
+        this.furnaceEventListener.setValues();
+
+        getLogger().info("FurnaceLevels wurde erfolgreich aktiviert!");
     }
+
+    @Override
+    public void onDisable() {
+        getLogger().info("FurnaceLevels wurde deaktiviert.");
     }
 
     private boolean setupEconomy() {
-    RegisteredServiceProvider<Economy> rsp = getServer().getServicesManager().getRegistration(Economy.class);
+        if (getServer().getPluginManager().getPlugin("Vault") == null) {
-    if (rsp == null)
             return false;
-    this.vaultEco = (Economy)rsp.getProvider();
+        }
+        RegisteredServiceProvider<Economy> rsp = getServer().getServicesManager().getRegistration(Economy.class);
+        if (rsp == null) {
+            return false;
+        }
+        this.vaultEco = rsp.getProvider();
         return (this.vaultEco != null);
     }
 }

src/main/java/vpd/bowandaero12/furnacelv/commands/DebugCmd.java

@@ -1,44 +1,50 @@
 package vpd.bowandaero12.furnacelv.commands;
 
-import java.util.HashSet;
+import org.bukkit.ChatColor;
-import java.util.Set;
-import java.util.UUID;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import vpd.bowandaero12.furnacelv.FurnaceLevels;
 
-public class DebugCmd implements CommandExecutor {
+import java.util.HashSet;
-  private FurnaceLevels plugin;
+import java.util.Set;
+import java.util.UUID;
 
-  private Set<UUID> debugging;
+public class DebugCmd implements CommandExecutor {
+    private final FurnaceLevels plugin;
+    private final Set<UUID> debugging = new HashSet<>();
 
     public DebugCmd(FurnaceLevels plugin) {
-    this.debugging = new HashSet<>();
         this.plugin = plugin;
     }
 
+    @Override
     public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
-    if (!(sender instanceof Player))
+        if (!(sender instanceof Player)) {
-      return true; 
+            sender.sendMessage("Dieser Befehl kann nur von einem Spieler ausgeführt werden.");
-    if (!sender.hasPermission("furnacelevels.debug")) {
-      sender.sendMessage(this.plugin.lvmenu.getLangMsg("no-permission", null));
-      return true;
-    } 
-    Player p = (Player)sender;
-    UUID uuid = p.getUniqueId();
-    if (!this.debugging.contains(uuid)) {
-      this.debugging.add(uuid);
-      p.sendMessage(this.plugin.lvmenu.getLangMsg("debug-enabled", null));
-      return true;
-    } 
-    p.sendMessage(this.plugin.lvmenu.getLangMsg("debug-disabled", null));
-    this.debugging.remove(uuid);
             return true;
         }
 
-  public Set<UUID> getDebugging() {
+        Player player = (Player) sender;
-    return this.debugging;
+        if (!player.hasPermission("furnacelevels.debug")) {
+            player.sendMessage(ChatColor.RED + "Du hast keine Berechtigung, diesen Befehl zu verwenden.");
+            return true;
+        }
+
+        UUID uuid = player.getUniqueId();
+        if (debugging.contains(uuid)) {
+            debugging.remove(uuid);
+            player.sendMessage(ChatColor.RED + "Debug-Modus deaktiviert.");
+        } else {
+            debugging.add(uuid);
+            player.sendMessage(ChatColor.GREEN + "Debug-Modus aktiviert.");
+        }
+
+        return true;
+    }
+
+    public boolean isDebugging(Player player) {
+        return debugging.contains(player.getUniqueId());
     }
 }

src/main/java/vpd/bowandaero12/furnacelv/commands/GiveCommand.java

@@ -0,0 +1,170 @@
+package vpd.bowandaero12.furnacelv.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import vpd.bowandaero12.furnacelv.FurnaceLevels;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class GiveCommand implements CommandExecutor {
+    private final FurnaceLevels plugin;
+
+    public GiveCommand(FurnaceLevels plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+
+        // --- Fall 1: Keine Argumente (/flgive) ---
+        if (args.length == 0) {
+            if (!(sender instanceof Player)) {
+                sender.sendMessage("Dieser Befehl kann nur von einem Spieler ausgeführt werden.");
+                return true;
+            }
+            Player player = (Player) sender;
+            if (!player.hasPermission("furnacelevels.give")) {
+                player.sendMessage(ChatColor.RED + "Du hast keine Berechtigung, diesen Befehl zu verwenden.");
+                return true;
+            }
+            giveItem(sender, 1, player); // Gib 1 Item an sich selbst
+            return true;
+        }
+
+        // --- Fall 2: Ein Argument (/flgive <Menge> oder /flgive <Spieler>) ---
+        if (args.length == 1) {
+            try {
+                // Versuche, das Argument als Zahl (Menge) zu interpretieren
+                int amount = Integer.parseInt(args[0]);
+                if (amount <= 0) {
+                    sender.sendMessage(ChatColor.RED + "Die Menge muss eine positive Zahl sein.");
+                    return true;
+                }
+                if (!(sender instanceof Player)) {
+                    sender.sendMessage("Dieser Befehl kann nur von einem Spieler ausgeführt werden.");
+                    return true;
+                }
+                Player player = (Player) sender;
+                if (!player.hasPermission("furnacelevels.give")) {
+                    player.sendMessage(ChatColor.RED + "Du hast keine Berechtigung, diesen Befehl zu verwenden.");
+                    return true;
+                }
+                giveItem(player, amount, player); // Gib <Menge> Items an sich selbst
+                return true;
+            } catch (NumberFormatException e) {
+                // Argument war keine Zahl, also ist es ein Spielername
+                Player target = Bukkit.getPlayer(args[0]);
+                if (target == null) {
+                    sender.sendMessage(ChatColor.RED + "Der Spieler '" + args[0] + "' ist nicht online.");
+                    return true;
+                }
+                if (!sender.hasPermission("furnacelevels.give.other")) {
+                    sender.sendMessage(ChatColor.RED + "Du hast keine Berechtigung, anderen Spielern Items zu geben.");
+                    return true;
+                }
+                giveItem(sender, 1, target); // Gib 1 Item an den anderen Spieler
+                return true;
+            }
+        }
+
+        // --- Fall 3: Zwei Argumente (/flgive <Spieler> <Menge>) ---
+        if (args.length == 2) {
+            Player target = Bukkit.getPlayer(args[0]);
+            if (target == null) {
+                sender.sendMessage(ChatColor.RED + "Der Spieler '" + args[0] + "' ist nicht online.");
+                return true;
+            }
+            if (!sender.hasPermission("furnacelevels.give.other")) {
+                sender.sendMessage(ChatColor.RED + "Du hast keine Berechtigung, anderen Spielern Items zu geben.");
+                return true;
+            }
+            try {
+                int amount = Integer.parseInt(args[1]);
+                if (amount <= 0) {
+                    sender.sendMessage(ChatColor.RED + "Die Menge muss eine positive Zahl sein.");
+                    return true;
+                }
+                giveItem(sender, amount, target); // Gib <Menge> Items an den anderen Spieler
+                return true;
+            } catch (NumberFormatException e) {
+                sender.sendMessage(ChatColor.RED + "'" + args[1] + "' ist keine gültige Zahl.");
+                return true;
+            }
+        }
+
+        // --- Fall 4: Zu viele Argumente ---
+        sender.sendMessage(ChatColor.RED + "Falsche Verwendung! Benutze: /flgive [Spieler] [Menge]");
+        return true;
+    }
+
+    /**
+     * Erstellt das Upgrade-Item und gibt es dem Ziel-Spieler.
+     *
+     * @param sender  Der, der den Befehl ausführt.
+     * @param amount  Die Menge des Items.
+     * @param target  Der Spieler, der das Item erhält.
+     */
+    private void giveItem(CommandSender sender, int amount, Player target) {
+        ItemStack upgradeItem = createUpgradeItem();
+        if (upgradeItem == null) {
+            sender.sendMessage(ChatColor.RED + "Das Upgrade-Item konnte aufgrund eines Fehlers in der Config nicht erstellt werden.");
+            return;
+        }
+        upgradeItem.setAmount(amount);
+
+        // Füge das Item zum Inventar hinzu und prüfe, ob es voll ist
+        // Die Map 'leftover' enthält die Items, die NICHT ins Inventar gepasst haben.
+        Map<Integer, ItemStack> leftover = target.getInventory().addItem(upgradeItem);
+
+        // KORREKTUR: Die Logik war hier vertauscht.
+        // Wenn 'leftover' NICHT leer ist, war das Inventar voll.
+        if (!leftover.isEmpty()) {
+            sender.sendMessage(ChatColor.RED + "Das Inventar von " + target.getName() + " ist voll! Die restlichen Items wurden am Boden fallengelassen.");
+            for (ItemStack item : leftover.values()) {
+                target.getWorld().dropItem(target.getLocation(), item);
+            }
+        } else {
+            // Erfolgsmeldung
+            if (sender.equals(target)) {
+                target.sendMessage(ChatColor.GREEN + "Du hast " + amount + " Ofen-Upgrade-Token erhalten.");
+            } else {
+                sender.sendMessage(ChatColor.GREEN + "Du hast " + amount + " Ofen-Upgrade-Token an " + target.getName() + " gegeben.");
+                target.sendMessage(ChatColor.GREEN + "Du hast " + amount + " Ofen-Upgrade-Token von " + sender.getName() + " erhalten.");
+            }
+        }
+    }
+
+    private ItemStack createUpgradeItem() {
+        String configMaterialName = plugin.getConfig().getString("item.material-type", "SUNFLOWER").toUpperCase();
+        String configDisplayName = ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("item.displayname", "&6&lOfen-Upgrade-Token"));
+        List<String> configLore = plugin.getConfig().getStringList("item.lore").stream()
+                .map(line -> ChatColor.translateAlternateColorCodes('&', line))
+                .collect(Collectors.toList());
+
+        Material configMaterial;
+        try {
+            configMaterial = Material.valueOf(configMaterialName);
+        } catch (IllegalArgumentException e) {
+            return null;
+        }
+
+        ItemStack item = new ItemStack(configMaterial);
+        ItemMeta meta = item.getItemMeta();
+        if (meta != null) {
+            meta.setDisplayName(configDisplayName);
+            meta.setLore(configLore);
+            item.setItemMeta(meta);
+        }
+        return item;
+    }
+}

src/main/java/vpd/bowandaero12/furnacelv/events/FurnaceEvent.java

@@ -2,65 +2,294 @@ package vpd.bowandaero12.furnacelv.events;
 
 import com.comphenix.protocol.PacketType;
 import com.comphenix.protocol.events.PacketContainer;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.List;
 import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
 import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
 import org.bukkit.block.Block;
 import org.bukkit.block.Furnace;
 import org.bukkit.entity.HumanEntity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
 import org.bukkit.event.inventory.FurnaceBurnEvent;
 import org.bukkit.event.inventory.FurnaceSmeltEvent;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
 import org.bukkit.scheduler.BukkitRunnable;
 import org.bukkit.util.BlockVector;
 import vpd.bowandaero12.furnacelv.FurnaceLevels;
 import vpd.bowandaero12.furnacelv.utils.Fuels;
 
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
 public class FurnaceEvent implements Listener {
 
-    private FurnaceLevels plugin;
+    private final FurnaceLevels plugin;
-    private Class<?> craftPlayer;
+    private final NamespacedKey furnaceLevelKey;
+    private final NamespacedKey menuKey;
     private Method getHandle;
-
+    private static final List<BlockVector> boosted = new ArrayList<>();
-    private static List<BlockVector> boosted = new ArrayList<>();
 
     public FurnaceEvent(FurnaceLevels plugin) {
         this.plugin = plugin;
+        this.furnaceLevelKey = new NamespacedKey(plugin, "furnace_level");
+        this.menuKey = new NamespacedKey(plugin, "furnace_menu");
     }
 
+    // --- EVENT 1: Upgrade mit Item (wenn Economy deaktiviert ist) ---
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onPlayerInteractItem(PlayerInteractEvent event) {
+        // Nur wenn Economy deaktiviert ist, diesen Teil des Codes ausführen
+        if (plugin.configs.getConfig().getBoolean("use-economy", true)) {
+            return;
+        }
+
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
+        if (event.getHand() != org.bukkit.inventory.EquipmentSlot.HAND) return;
+
+        Player player = event.getPlayer();
+        Block clickedBlock = event.getClickedBlock();
+        if (clickedBlock == null || !isFurnace(clickedBlock.getType())) return;
+
+        ItemStack itemInHand = player.getInventory().getItemInMainHand();
+        if (!isUpgradeItem(itemInHand)) return;
+
+        event.setCancelled(true);
+
+        Furnace furnace = (Furnace) clickedBlock.getState();
+        PersistentDataContainer container = furnace.getPersistentDataContainer();
+        int currentLevel = container.getOrDefault(furnaceLevelKey, PersistentDataType.INTEGER, 0);
+        int maxLevel = plugin.getConfig().getConfigurationSection("upgrades").getKeys(false).size();
+
+        if (currentLevel >= maxLevel) {
+            player.sendMessage(ChatColor.RED + "Dieser Ofen hat bereits das maximale Level (" + maxLevel + ") erreicht!");
+            return;
+        }
+
+        int newLevel = currentLevel + 1;
+        String permission = "furnacelevels.upgrade." + newLevel;
+
+        if (!player.hasPermission(permission)) {
+            player.sendMessage(ChatColor.RED + "Du hast keine Berechtigung, um einen Ofen auf Level " + newLevel + " zu upgraden!");
+            player.sendMessage(ChatColor.GRAY + "Benötigte Berechtigung: " + permission);
+            return;
+        }
+
+        container.set(furnaceLevelKey, PersistentDataType.INTEGER, newLevel);
+        furnace.update();
+
+        player.sendMessage(ChatColor.GREEN + "Ofen erfolgreich auf Level " + newLevel + " aktualisiert!");
+        removeOneItem(player);
+    }
+
+    // --- EVENT 2: Upgrade mit Economy (wenn Economy aktiviert ist) ---
+    @EventHandler(priority = EventPriority.HIGH)
+    public void onPlayerInteractEconomy(PlayerInteractEvent event) {
+        // Nur wenn Economy aktiviert ist, diesen Teil des Codes ausführen
+        if (!plugin.configs.getConfig().getBoolean("use-economy", true)) {
+            return;
+        }
+
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
+        if (!event.getPlayer().isSneaking()) return; // Wichtig: Nur beim Schleichen
+
+        Player player = event.getPlayer();
+        Block clickedBlock = event.getClickedBlock();
+        if (clickedBlock == null || !isFurnace(clickedBlock.getType())) return;
+
+        // Verhindere, dass das normale Ofen-Inventar geöffnet wird
+        event.setCancelled(true);
+
+        // Öffne das Upgrade-Menü
+        player.openInventory(createUpgradeMenu(clickedBlock));
+    }
+
+    // --- EVENT 3: Klicks im Economy-Menü verarbeiten ---
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) {
+        if (event.getInventory().getHolder() != null) return; // Sicherstellen, dass es kein normales Inventar ist
+        if (!event.getView().getTitle().equals(ChatColor.DARK_GRAY + "Ofen verbessern")) return;
+
+        event.setCancelled(true); // Verhindere, dass man Items rausnehmen kann
+        Player player = (Player) event.getWhoClicked();
+        if (event.getCurrentItem() == null) return;
+
+        // Klick auf "Kaufen"-Button (Smaragd)
+        if (event.getCurrentItem().getType() == Material.EMERALD_BLOCK) {
+            String furnaceLocStr = event.getView().getItem(0).getItemMeta().getDisplayName().substring("Ofen-Location: ".length());
+            Block furnaceBlock = parseLocation(furnaceLocStr);
+            if (furnaceBlock == null) {
+                player.sendMessage(ChatColor.RED + "Fehler: Ofen nicht gefunden.");
+                player.closeInventory();
+                return;
+            }
+
+            Furnace furnace = (Furnace) furnaceBlock.getState();
+            PersistentDataContainer container = furnace.getPersistentDataContainer();
+            int currentLevel = container.getOrDefault(furnaceLevelKey, PersistentDataType.INTEGER, 0);
+            int newLevel = currentLevel + 1;
+            String permission = "furnacelevels.upgrade." + newLevel;
+
+            if (!player.hasPermission(permission)) {
+                player.sendMessage(ChatColor.RED + "Du hast keine Berechtigung für dieses Upgrade!");
+                player.closeInventory();
+                return;
+            }
+
+            // *** WICHTIGE KORREKTUR: EXPLIZITE TYPUMWANDLUNG, UM DEN COMPILER-FEHLER ZU BEHEBEN ***
+            double cost = plugin.getConfig().getDouble("upgrades.level-" + newLevel + ".cost");
+            double playerBalance = plugin.vaultEco.getBalance(player);
+
+            if (playerBalance < cost) {
+                player.sendMessage(ChatColor.RED + "Du hast nicht genug Geld! Du benötigst " + cost + ".");
+                player.closeInventory();
+                return;
+            }
+
+            // Alles okay, Upgrade durchführen
+            plugin.vaultEco.withdrawPlayer(player, cost);
+            container.set(furnaceLevelKey, PersistentDataType.INTEGER, newLevel);
+            furnace.update();
+
+            player.sendMessage(ChatColor.GREEN + "Ofen erfolgreich auf Level " + newLevel + " für " + cost + " verbessert!");
+            player.closeInventory();
+        } else if (event.getCurrentItem().getType() == Material.REDSTONE_BLOCK) { // Klick auf "Abbrechen"-Button (Redstone)
+            player.closeInventory();
+        }
+    }
+
+    // --- BESTEHENDE LOGIK (Ofen-Beschleunigung) ---
+
     @EventHandler
     public void onSmelt(FurnaceSmeltEvent event) {
         Block block = event.getBlock();
-        Furnace furnace = (Furnace) block.getState();
+        int level = getFurnaceLevel(block);
-        if (furnace.getInventory().getFuel() != null &&
+        if (level > 0 && event.getSource().getType() != Material.AIR) {
-            this.plugin.itemhandler.getFurnaceTrack().get(block.getLocation()) != null) {
+            runFurnace(block, event.getSource().getType(), level);
-            runFurnace(block, furnace.getInventory().getFuel().getType(),
-                    this.plugin.itemhandler.getFurnaceTrack().get(block.getLocation()));
         }
     }
 
     @EventHandler
     public void onFurnace(FurnaceBurnEvent event) {
-        if (this.plugin.configs.getLang().getStringList("world-blacklist")
+        if (plugin.configs.getLang().getStringList("world-blacklist").contains(event.getBlock().getWorld().getName())) return;
-                .contains(event.getBlock().getWorld().getName())) return;
 
         Block block = event.getBlock();
-        if (this.plugin.itemhandler.getFurnaceTrack().get(block.getLocation()) != null) {
+        int level = getFurnaceLevel(block);
-            runFurnace(block, event.getFuel().getType(),
+        if (level > 0) {
-                    this.plugin.itemhandler.getFurnaceTrack().get(block.getLocation()));
+            runFurnace(block, event.getFuel().getType(), level);
         }
     }
 
+    // --- Hilfsmethoden ---
+
+    private Inventory createUpgradeMenu(Block furnaceBlock) {
+        Furnace furnace = (Furnace) furnaceBlock.getState();
+        PersistentDataContainer container = furnace.getPersistentDataContainer();
+        int currentLevel = container.getOrDefault(furnaceLevelKey, PersistentDataType.INTEGER, 0);
+        int maxLevel = plugin.getConfig().getConfigurationSection("upgrades").getKeys(false).size();
+
+        String title = ChatColor.DARK_GRAY + "Ofen verbessern";
+        Inventory gui = Bukkit.createInventory(null, 9, title);
+
+        // Ofen-Info (Buch)
+        ItemStack info = new ItemStack(Material.BOOK);
+        ItemMeta infoMeta = info.getItemMeta();
+        infoMeta.setDisplayName(ChatColor.GOLD + "Ofen-Statistiken");
+        infoMeta.setLore(Arrays.asList(
+                ChatColor.GRAY + "Aktuelles Level: " + ChatColor.YELLOW + currentLevel,
+                ChatColor.GRAY + "Maximales Level: " + ChatColor.YELLOW + maxLevel
+        ));
+        info.setItemMeta(infoMeta);
+        gui.setItem(4, info);
+
+        if (currentLevel >= maxLevel) {
+            // Max-Level erreicht
+            ItemStack max = new ItemStack(Material.BARRIER);
+            ItemMeta maxMeta = max.getItemMeta();
+            maxMeta.setDisplayName(ChatColor.RED + "Maximales Level erreicht!");
+            maxMeta.setLore(Arrays.asList(ChatColor.GRAY + "Dieser Ofen kann nicht weiter verbessert werden."));
+            max.setItemMeta(maxMeta);
+            gui.setItem(2, max);
+        } else {
+            // Upgrade-Optionen
+            int nextLevel = currentLevel + 1;
+            // Auch hier lesen wir die Kosten als 'double'
+            double cost = plugin.getConfig().getDouble("upgrades.level-" + nextLevel + ".cost");
+            short speed = (short) plugin.getConfig().getInt("upgrades.level-" + nextLevel + ".ticks-per-tick");
+
+            // Kaufen-Button (Smaragd)
+            ItemStack confirm = new ItemStack(Material.EMERALD_BLOCK);
+            ItemMeta confirmMeta = confirm.getItemMeta();
+            confirmMeta.setDisplayName(ChatColor.GREEN + "Auf Level " + nextLevel + " verbessern");
+            confirmMeta.setLore(Arrays.asList(
+                    ChatColor.GRAY + "Kosten: " + ChatColor.YELLOW + cost,
+                    ChatColor.GRAY + "Neue Geschwindigkeit: " + ChatColor.YELLOW + speed + "x"
+            ));
+            confirm.setItemMeta(confirmMeta);
+            gui.setItem(2, confirm);
+        }
+
+        // Abbrechen-Button (Redstone)
+        ItemStack cancel = new ItemStack(Material.REDSTONE_BLOCK);
+        ItemMeta cancelMeta = cancel.getItemMeta();
+        cancelMeta.setDisplayName(ChatColor.RED + "Abbrechen");
+        cancelMeta.setLore(Arrays.asList(ChatColor.GRAY + "Schließt dieses Menü."));
+        cancel.setItemMeta(cancelMeta);
+        gui.setItem(6, cancel);
+
+        // Verstecktes Item, um die Ofen-Location zu speichern
+        ItemStack locationHolder = new ItemStack(Material.PAPER);
+        ItemMeta locationMeta = locationHolder.getItemMeta();
+        locationMeta.setDisplayName("Ofen-Location: " + serializeLocation(furnaceBlock.getLocation()));
+        locationMeta.setLore(Arrays.asList("")); // Leere Lore, damit es nicht so auffällt
+        locationHolder.setItemMeta(locationMeta);
+        gui.setItem(0, locationHolder); // In einer Ecke platzieren
+
+        return gui;
+    }
+
+    private Block parseLocation(String locStr) {
+        try {
+            String[] parts = locStr.split(",");
+            // Parse double, dann auf Block-Koordinaten runden (floor) und int an getBlockAt übergeben
+            double x = Double.parseDouble(parts[1]);
+            double y = Double.parseDouble(parts[2]);
+            double z = Double.parseDouble(parts[3]);
+            int xi = (int) Math.floor(x);
+            int yi = (int) Math.floor(y);
+            int zi = (int) Math.floor(z);
+            return Bukkit.getWorld(parts[0]).getBlockAt(xi, yi, zi);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    private String serializeLocation(org.bukkit.Location loc) {
+        return loc.getWorld().getName() + "," + loc.getX() + "," + loc.getY() + "," + loc.getZ();
+    }
+
+    private int getFurnaceLevel(Block block) {
+        if (!(block.getState() instanceof Furnace)) return 0;
+        Furnace furnace = (Furnace) block.getState();
+        return furnace.getPersistentDataContainer().getOrDefault(furnaceLevelKey, PersistentDataType.INTEGER, 0);
+    }
+
     private short getTicks(Integer level) {
         if (level == 0) return 0;
-        return (short) this.plugin.configs.getConfig()
+        return (short) plugin.configs.getConfig().getInt("upgrades.level-" + level + ".ticks-per-tick");
-                .getInt("upgrades.level-" + level + ".ticks-per-tick");
     }
 
     private void runFurnace(final Block block, final Material burning, int level) {
@@ -69,108 +298,105 @@ public class FurnaceEvent implements Listener {
 
         if (!boosted.contains(block.getLocation().toVector().toBlockVector())) {
             boosted.add(block.getLocation().toVector().toBlockVector());
-
             new BukkitRunnable() {
                 public void run() {
                     Furnace furnace;
-                    try {
+                    try { furnace = (Furnace) block.getState(); }
-                        furnace = (Furnace) block.getState();
+                    catch (ClassCastException e) { cancel(); return; }
-                    } catch (ClassCastException e) {
-                        cancel();
-                        return;
-                    }
 
                     if (furnace.getCookTime() > 0 || furnace.getBurnTime() > 0) {
                         short burnTime = (short) (furnace.getBurnTime() - speedUp + 1);
                         short cookTime = (short) (furnace.getCookTime() + speedUp - 1);
-
                         if (cookTime > 200) cookTime = 199;
                         furnace.setCookTime(cookTime);
-
+                        if (burnTime < 0) { furnace.setBurnTime((short) 1); furnace.update(); boosted.remove(block.getLocation().toVector().toBlockVector()); cancel(); return; }
-                        if (burnTime < 0) {
+                        furnace.setBurnTime(burnTime); furnace.update();
-                            furnace.setBurnTime((short) 1);
-                            furnace.update();
-                            boosted.remove(block.getLocation().toVector().toBlockVector());
-                            cancel();
-                            return;
-                        }
-                        furnace.setBurnTime(burnTime);
-                        furnace.update();
 
                         if (!furnace.getInventory().getViewers().isEmpty()) {
                             HumanEntity viewer = furnace.getInventory().getViewers().get(0);
                             if (!(viewer instanceof Player)) return;
                             Player player = (Player) viewer;
-
+                            int windowID = getWindowId(player);
-                            int windowID = -1;
-                            try {
-                                Object entityPlayer = getHandle.invoke(player);
-
-                                for (Field field : entityPlayer.getClass().getDeclaredFields()) {
-                                    if (field.getType().getSimpleName().equals("Container")) {
-                                        field.setAccessible(true);
-                                        Object container = field.get(entityPlayer);
-                                        for (Field f : container.getClass().getDeclaredFields()) {
-                                            if (f.getType() == int.class && f.getName().toLowerCase().contains("window")) {
-                                                f.setAccessible(true);
-                                                windowID = f.getInt(container);
-                                                break;
-                                            }
-                                        }
-                                        break;
-                                    }
-                                }
-                            } catch (IllegalAccessException | InvocationTargetException e) {
-                                e.printStackTrace();
-                                return;
-                            }
-
                             if (windowID == -1) return;
 
                             PacketContainer max = new PacketContainer(PacketType.Play.Server.WINDOW_DATA);
-                            max.getIntegers().writeDefaults();
+                            max.getIntegers().write(0, windowID); max.getIntegers().write(1, 1); max.getIntegers().write(2, getBurnTime(burning));
-                            max.getIntegers().write(0, windowID);
-                            max.getIntegers().write(1, 1);
-                            max.getIntegers().write(2, getBurnTime(burning));
-
                             PacketContainer current = new PacketContainer(PacketType.Play.Server.WINDOW_DATA);
-                            current.getIntegers().writeDefaults();
+                            current.getIntegers().write(0, windowID); current.getIntegers().write(1, 0);
-                            current.getIntegers().write(0, windowID);
+                            int fraction = (burnTime * 100) / getBurnTime(burning);
-                            current.getIntegers().write(1, 0);
-                            int fraction = burnTime * 100 / getBurnTime(burning);
                             current.getIntegers().write(2, fraction);
 
-                            plugin.protocolManager.sendServerPacket(player, max);
+                            try { plugin.protocolManager.sendServerPacket(player, max); plugin.protocolManager.sendServerPacket(player, current); }
-                            plugin.protocolManager.sendServerPacket(player, current);
+                            catch (Exception e) { /* Ignorieren */ }
                         }
-
+                    } else { boosted.remove(block.getLocation().toVector().toBlockVector()); cancel(); }
-                    } else {
-                        boosted.remove(block.getLocation().toVector().toBlockVector());
-                        cancel();
                 }
-                }
+            }.runTaskTimer(plugin, 1L, 1L);
-            }.runTaskTimer(this.plugin, 1L, 1L);
         }
     }
 
-    private String getServerVersion() {
+    private int getWindowId(Player player) {
+        if (this.getHandle == null) return -1;
         try {
-            return Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+            Object entityPlayer = getHandle.invoke(player);
-        } catch (ArrayIndexOutOfBoundsException err) {
+            for (java.lang.reflect.Field field : entityPlayer.getClass().getSuperclass().getDeclaredFields()) {
-            return "unknown";
+                if (field.getType().getSimpleName().contains("Container")) {
+                    field.setAccessible(true); Object container = field.get(entityPlayer);
+                    if (container == null) continue;
+                    for (java.lang.reflect.Field f : container.getClass().getDeclaredFields()) {
+                        if (f.getType() == int.class && f.getName().toLowerCase().contains("window")) {
+                            f.setAccessible(true); return f.getInt(container);
                         }
                     }
+                }
+            }
+        } catch (IllegalAccessException | InvocationTargetException e) { return -1; }
+        return -1;
+    }
 
     public void setValues() {
         try {
-            this.craftPlayer = Class.forName("org.bukkit.craftbukkit." + getServerVersion() + ".entity.CraftPlayer");
+            String version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+            Class<?> craftPlayer = Class.forName("org.bukkit.craftbukkit." + version + ".entity.CraftPlayer");
             this.getHandle = craftPlayer.getMethod("getHandle");
-        } catch (ClassNotFoundException | NoSuchMethodException err) {
+        } catch (Exception err) {
-            err.printStackTrace();
+            plugin.getLogger().warning("Konnte Reflektion für ProtocolLib nicht initialisieren. Visuelle Updates könnten nicht funktionieren.");
         }
     }
 
     private int getBurnTime(Material material) {
-        return Fuels.fromString(material.toString()).getDuration();
+        // Fuels.fromString(...).getDuration() könnte double zurückgeben — hier runden und auf mindestens 1 kappen.
+        try {
+            double duration = Fuels.fromString(material.toString()).getDuration();
+            return Math.max(1, (int) Math.round(duration));
+        } catch (Exception e) {
+            // Fallback: wenn etwas schief geht, mindestens 1 zurückgeben
+            return 1;
+        }
+    }
+
+    private boolean isFurnace(Material material) {
+        return material == Material.FURNACE || material == Material.BLAST_FURNACE || material == Material.SMOKER;
+    }
+
+    private boolean isUpgradeItem(ItemStack item) {
+        if (item == null || item.getType() == Material.AIR) return false;
+        String configMaterialName = plugin.getConfig().getString("item.material-type", "SUNFLOWER").toUpperCase();
+        String configDisplayName = ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("item.displayname", "&6&lOfen-Upgrade-Token"));
+        List<String> configLore = plugin.getConfig().getStringList("item.lore").stream().map(line -> ChatColor.translateAlternateColorCodes('&', line)).collect(Collectors.toList());
+        Material configMaterial;
+        try { configMaterial = Material.valueOf(configMaterialName); }
+        catch (IllegalArgumentException e) { plugin.getLogger().warning("Das Material '" + configMaterialName + "' in der Config ist ungültig."); return false; }
+        if (item.getType() != configMaterial || !item.hasItemMeta()) return false;
+        ItemMeta meta = item.getItemMeta();
+        if (!meta.hasDisplayName() || !meta.getDisplayName().equals(configDisplayName)) return false;
+        if (!meta.hasLore() || !meta.getLore().equals(configLore)) return false;
+        return true;
+    }
+
+    private void removeOneItem(Player player) {
+        ItemStack item = player.getInventory().getItemInMainHand();
+        if (item.getAmount() > 1) { item.setAmount(item.getAmount() - 1); }
+        else { player.getInventory().setItemInMainHand(null); }
     }
 }

src/main/java/vpd/bowandaero12/furnacelv/items/ItemHandler.java

@@ -1,206 +0,0 @@
-package vpd.bowandaero12.furnacelv.items;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.GameMode;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.block.Block;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.block.BlockBreakEvent;
-import org.bukkit.event.block.BlockPlaceEvent;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import vpd.bowandaero12.furnacelv.FurnaceLevels;
-
-public class ItemHandler implements Listener {
-  private FurnaceLevels plugin;
-  
-  private Map<Location, Integer> furnaceTrack;
-  
-  public ItemHandler(FurnaceLevels plugin) {
-    this.furnaceTrack = new HashMap<>();
-    this.plugin = plugin;
-  }
-  
-  public Map<Location, Integer> getFurnaceTrack() {
-    return this.furnaceTrack;
-  }
-  
-  public void registerFurnaces() {
-    for (String s : this.plugin.configs.getFData().getStringList("furnaces")) {
-      String[] coordsSplit = s.split(",");
-      Location loc = new Location(Bukkit.getServer().getWorld(coordsSplit[0]), Double.parseDouble(coordsSplit[1]), Double.parseDouble(coordsSplit[2]), Double.parseDouble(coordsSplit[3]));
-      int lv = Integer.parseInt(coordsSplit[4]);
-      this.furnaceTrack.put(loc, Integer.valueOf(lv));
-    } 
-  }
-  
-  @EventHandler
-  public void onBlockPlace(BlockPlaceEvent e) {
-    if (!this.plugin.configs.getConfig().getBoolean("use-economy") && 
-      e.getItemInHand().isSimilar(customItem())) {
-      e.setCancelled(true);
-      return;
-    } 
-    if (e.getBlock().getType() != Material.FURNACE)
-      return; 
-    Inventory inv = Bukkit.createInventory(null, 27);
-    inv.removeItem(new ItemStack[] { customItem(), customItem() });
-    Block block = e.getBlockPlaced();
-    Location loc = block.getLocation();
-    ItemStack item = e.getItemInHand();
-    String displayname = item.getItemMeta().getDisplayName();
-    List<String> lore = item.getItemMeta().getLore();
-    List<String> furnaceList = this.plugin.configs.getFData().getStringList("furnaces");
-    int lv = 0;
-    if (item.getItemMeta().hasDisplayName()) {
-      if (isLevel(item, 1, addColor("&7Level 1 Furnace"))) {
-        lv = 1;
-      } else if (isLevel(item, 2, addColor("&fLevel 2 Furnace"))) {
-        lv = 2;
-      } else if (isLevel(item, 3, addColor("&aLevel 3 Furnace"))) {
-        lv = 3;
-      } else if (isLevel(item, 4, addColor("&9Level 4 Furnace"))) {
-        lv = 4;
-      } else if (isLevel(item, 5, addColor("&5Level 5 Furnace"))) {
-        lv = 5;
-      } else {
-        e.getPlayer().sendMessage(this.plugin.lvmenu.getLangMsg("furnace-placed", Integer.valueOf(lv)));
-        return;
-      } 
-      furnaceList.add(serialize(loc, lv));
-      this.furnaceTrack.put(loc, Integer.valueOf(lv));
-      this.plugin.configs.getFData().set("furnaces", furnaceList);
-      this.plugin.configs.saveData();
-    } 
-    e.getPlayer().sendMessage(this.plugin.lvmenu.getLangMsg("furnace-placed", Integer.valueOf(lv)));
-  }
-  
-  @EventHandler
-  public void onBlockBreak(BlockBreakEvent e) {
-    if (e.getBlock().getType() != Material.FURNACE)
-      return; 
-    Location loc = e.getBlock().getLocation();
-    if (this.furnaceTrack.get(loc) != null) {
-      if (this.plugin.configs.getConfig().getBoolean("refund-cost")) {
-        int refund = 0;
-        for (int i = 1; i <= ((Integer)this.furnaceTrack.get(loc)).intValue(); i++)
-          refund += this.plugin.configs.getConfig().getInt("upgrades.level-" + i + ".cost"); 
-        if (this.plugin.vaultEco != null) {
-          this.plugin.vaultEco.depositPlayer((OfflinePlayer)e.getPlayer(), refund);
-        } else {
-          ItemStack item = customItem();
-          item.setAmount(refund);
-          e.getPlayer().getInventory().addItem(new ItemStack[] { item });
-        } 
-      } else {
-        e.setDropItems(false);
-        ItemStack furnaceItem = new ItemStack(Material.FURNACE);
-        ItemMeta meta = furnaceItem.getItemMeta();
-        int lv = ((Integer)this.furnaceTrack.get(loc)).intValue();
-        if (lv == 0) {
-          List<String> list = getFData().getStringList("furnaces");
-          list.remove(serialize(loc, ((Integer)this.furnaceTrack.get(loc)).intValue()));
-          getFData().set("furnaces", list);
-          this.plugin.configs.saveData();
-          this.furnaceTrack.remove(loc);
-          return;
-        } 
-        setLangLore(meta, "level-" + lv + ".lore").setDisplayName(addColor(getLang().getString("level-" + lv + ".name")));
-        furnaceItem.setItemMeta(meta);
-        if (e.getPlayer().getGameMode() == GameMode.CREATIVE)
-          return; 
-        Material mainHand = getItemInHand(e.getPlayer()).getType();
-        if (mainHand.toString().contains("_PICKAXE")) {
-          e.getBlock().getWorld().dropItemNaturally(loc.add(0.5D, 0.5D, 0.5D), furnaceItem);
-          loc.add(-0.5D, -0.5D, -0.5D);
-        } 
-      } 
-      List<String> furnaceList = getFData().getStringList("furnaces");
-      furnaceList.remove(serialize(loc, ((Integer)this.furnaceTrack.get(loc)).intValue()));
-      getFData().set("furnaces", furnaceList);
-      this.plugin.configs.saveData();
-      this.furnaceTrack.remove(loc);
-    } 
-  }
-  
-  private FileConfiguration getLang() {
-    return this.plugin.configs.getLang();
-  }
-  
-  private FileConfiguration getFData() {
-    return this.plugin.configs.getFData();
-  }
-  
-  String serialize(Location loc, int level) {
-    if (loc == null)
-      throw new IllegalArgumentException(); 
-    return loc.getWorld().getName() + "," + loc.getX() + "," + loc.getY() + "," + loc.getZ() + "," + level;
-  }
-  
-  private boolean isLevel(ItemStack item, int level, String defaultname) {
-    String name;
-    ItemMeta meta = item.getItemMeta();
-    List<String> lore = new ArrayList<>();
-    if (meta.hasLore())
-      lore = meta.getLore(); 
-    if (!meta.hasDisplayName())
-      return (level == 0); 
-    String displayname = meta.getDisplayName();
-    if (getLang().isSet("level-" + level + ".name")) {
-      name = addColor(getLang().getString("level-" + level + ".name"));
-    } else {
-      name = defaultname;
-    } 
-    return (displayname.equals(name) && lore.equals(getLang().getStringList("level-" + level + ".lore")));
-  }
-  
-  private ItemMeta setLangLore(ItemMeta meta, String path) {
-    List<String> lore = new ArrayList<>();
-    for (String s : getLang().getStringList(path))
-      lore.add(addColor(s)); 
-    meta.setLore(lore);
-    return meta;
-  }
-  
-  private String addColor(String string) {
-    return ChatColor.translateAlternateColorCodes('&', string);
-  }
-  
-  ItemStack customItem() {
-    String mat;
-    ConfigurationSection iteminfo = this.plugin.configs.getConfig().getConfigurationSection("item");
-    String[] split = iteminfo.getString("material-type").split(":");
-    if (split.length == 1) {
-      mat = split[0].toUpperCase();
-    } else {
-      mat = split[1].toUpperCase();
-    } 
-    Material material = Material.valueOf(mat);
-    String displayname = ChatColor.translateAlternateColorCodes('&', iteminfo.getString("displayname"));
-    List<String> lore = new ArrayList<>();
-    for (String s : iteminfo.getStringList("lore"))
-      lore.add(ChatColor.translateAlternateColorCodes('&', s)); 
-    ItemStack item = this.plugin.lvmenu.createItem(material, displayname, lore);
-    if (!this.plugin.getServer().getVersion().contains("1.13"))
-      item.getData().setData((byte)iteminfo.getInt("data")); 
-    return item;
-  }
-  
-  private ItemStack getItemInHand(Player p) {
-    if (this.plugin.getServer().getVersion().contains("1.8"))
-      return p.getItemInHand(); 
-    return p.getInventory().getItemInMainHand();
-  }
-}

src/main/java/vpd/bowandaero12/furnacelv/items/LevelMenu.java

@@ -1,268 +0,0 @@
-package vpd.bowandaero12.furnacelv.items;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.GameMode;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.block.Furnace; // Nur diesen Import behalten
-import org.bukkit.enchantments.Enchantment;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.block.Action;
-import org.bukkit.event.inventory.ClickType;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.scheduler.BukkitRunnable;
-import org.bukkit.util.Vector;
-import vpd.bowandaero12.furnacelv.FurnaceLevels;
-import vpd.bowandaero12.furnacelv.utils.Fuels;
-
-public class LevelMenu implements Listener {
-    private FurnaceLevels plugin;
-    private Map<UUID, Integer> debug;
-
-    public LevelMenu(FurnaceLevels plugin) {
-        this.debug = new HashMap<>();
-        this.plugin = plugin;
-    }
-
-    private Integer getCost(int level) {
-        if (level == 0)
-            return 0;
-        return this.plugin.configs.getConfig().getInt("upgrades.level-" + level + ".cost");
-    }
-
-    private Inventory createInv(int level) {
-        Inventory gui;
-        ItemStack glass = Fuels.BLACK_STAINED_GLASS_PANE.parseItem();
-        ItemMeta meta = glass.getItemMeta();
-        meta.setDisplayName(ChatColor.BLACK.toString());
-        glass.setItemMeta(meta);
-        if (level < 5) {
-            gui = Bukkit.createInventory(null, 9, getLangMsg("level-gui.name", level));
-            gui.setItem(2, createItem(Material.EMERALD_BLOCK, getLangMsg("level-gui.items.emerald-block.name", level), getLangList("level-gui.items.emerald-block.lore", level)));
-        } else {
-            gui = Bukkit.createInventory(null, 9, getLangMsg("level-gui.max-level-name", level));
-            gui.setItem(2, createItem(Material.OBSIDIAN, getLangMsg("level-gui.items.obsidian.name", level), getLangList("level-gui.items.obsidian.lore", level)));
-        }
-        gui.setItem(6, createItem(Material.REDSTONE_BLOCK, getLangMsg("level-gui.items.redstone-block.name", level), getLangList("level-gui.items.redstone-block.lore", level)));
-        ItemStack book = createItem(Material.BOOK, getLangMsg("level-gui.items.book.name", level), getLangList("level-gui.items.book.lore", level));
-        ItemMeta bookmeta = book.getItemMeta();
-        bookmeta.addEnchant(Enchantment.UNBREAKING, 1, true);
-        book.setItemMeta(bookmeta);
-        gui.setItem(4, book);
-        for (Integer i : Arrays.asList(0, 8)) {
-            gui.setItem(i, glass);
-        }
-        return gui;
-    }
-
-    @EventHandler
-    public void onShiftRightClick(PlayerInteractEvent e) {
-        if (e.getAction() != Action.RIGHT_CLICK_BLOCK)
-            return;
-        Block block = e.getClickedBlock();
-        Player p = e.getPlayer();
-        if (p.isSneaking()) {
-            if (p.getInventory().getItemInMainHand().getType() != Material.AIR)
-                return;
-            if (block.getType() != Material.FURNACE)
-                return;
-            e.setCancelled(true);
-            if (((org.bukkit.block.data.type.Furnace) block.getBlockData()).isLit()) {
-                burn(p, block);
-                return;
-            }
-            try {
-                p.openInventory(createInv(getFurnaceTrack().getOrDefault(block.getLocation(), 0)));
-            } catch (NullPointerException err) {
-                getFurnaceTrack().put(block.getLocation(), 0);
-                p.openInventory(createInv(getFurnaceTrack().get(block.getLocation())));
-            }
-        }
-    }
-
-    @EventHandler
-    public void onInventoryClick(InventoryClickEvent e) {
-        UUID uuid = e.getWhoClicked().getUniqueId();
-        if (!this.plugin.configs.getConfig().getBoolean("use-economy") && e.getClickedInventory() == null) {
-            if (!this.plugin.debug.getDebugging().contains(uuid))
-                return;
-            if (e.getClick() == ClickType.LEFT) {
-                if (this.debug.get(uuid) == null) {
-                    this.debug.put(uuid, 1);
-                } else if (this.debug.get(uuid) == 2) {
-                    this.debug.put(uuid, this.debug.get(uuid) + 1);
-                } else {
-                    this.debug.remove(uuid);
-                }
-            } else if (e.getClick() == ClickType.RIGHT) {
-                if (this.debug.get(uuid) == null || this.debug.get(uuid) != 1) {
-                    this.debug.remove(uuid);
-                } else {
-                    this.debug.put(uuid, this.debug.get(uuid) + 1);
-                }
-            } else if (e.getClick() == ClickType.MIDDLE) {
-                if (this.debug.get(uuid) != null && this.debug.get(uuid) == 3)
-                    e.getWhoClicked().getInventory().addItem(new ItemStack[]{this.plugin.itemhandler.customItem()});
-                this.debug.remove(uuid);
-            }
-            return;
-        }
-        final Player p = (Player) e.getWhoClicked();
-        String invTitle = e.getView().getTitle();
-        org.bukkit.block.Furnace furnace; // Explizite Deklaration
-        try {
-            furnace = (org.bukkit.block.Furnace) p.getTargetBlock(null, 5).getState();
-            if (!invTitle.equals(getLangMsg("level-gui.name", getFurnaceLevel(furnace))) &&
-                !invTitle.equals(getLangMsg("level-gui.max-level-name", 5)))
-                return;
-        } catch (ClassCastException err) {
-            return;
-        }
-        if (e.getCurrentItem() == null)
-            return;
-        if (e.getCurrentItem().getType() == Material.REDSTONE_BLOCK) {
-            new BukkitRunnable() {
-                public void run() {
-                    p.closeInventory();
-                }
-            }.runTask(this.plugin);
-        } else if (e.getCurrentItem().getType() == Material.EMERALD_BLOCK) {
-            try {
-                furnace = (org.bukkit.block.Furnace) p.getTargetBlock(null, 5).getState();
-                if (!invTitle.equals(getLangMsg("level-gui.name", getFurnaceLevel(furnace))) &&
-                    !invTitle.equals(getLangMsg("level-gui.max-level-name", 5)))
-                    return;
-            } catch (ClassCastException err) {
-                p.sendMessage(getLangMsg("error", null));
-                return;
-            }
-            int currentLv = getFurnaceLevel(furnace);
-            if (!hasPermission(p, currentLv + 1)) {
-                p.sendMessage(getLangMsg("no-level-permission", currentLv));
-                e.setCancelled(true);
-                return;
-            }
-            double cost = getCost(currentLv + 1);
-            if (this.plugin.vaultEco != null) {
-                if (this.plugin.vaultEco.getBalance(p) >= cost) {
-                    this.plugin.vaultEco.withdrawPlayer(p, cost);
-                } else {
-                    p.sendMessage(getLangMsg("not-enough-money", currentLv));
-                    e.setCancelled(true);
-                    return;
-                }
-            } else {
-                ItemStack item = this.plugin.itemhandler.customItem();
-                item.setAmount((int) cost);
-                if (p.getInventory().containsAtLeast(item, (int) cost)) {
-                    p.getInventory().removeItem(new ItemStack[]{item});
-                } else {
-                    p.sendMessage(getLangMsg("not-enough-money", currentLv));
-                    e.setCancelled(true);
-                    return;
-                }
-            }
-            List<String> furnaces = this.plugin.configs.getFData().getStringList("furnaces");
-            furnaces.remove(this.plugin.itemhandler.serialize(furnace.getLocation(), currentLv));
-            furnaces.add(this.plugin.itemhandler.serialize(furnace.getLocation(), currentLv + 1));
-            this.plugin.configs.getFData().set("furnaces", furnaces);
-            this.plugin.configs.saveData();
-            getFurnaceTrack().put(furnace.getLocation(), currentLv + 1);
-            p.sendMessage(getLangMsg("successful-purchase", currentLv + 1));
-            new BukkitRunnable() {
-                public void run() {
-                    p.closeInventory();
-                }
-            }.runTask(this.plugin);
-        }
-        e.setCancelled(true);
-    }
-
-    private Map<Location, Integer> getFurnaceTrack() {
-        return this.plugin.itemhandler.getFurnaceTrack();
-    }
-
-    private int getFurnaceLevel(org.bukkit.block.Furnace furnace) { // Expliziter Typ
-        return getFurnaceTrack().getOrDefault(furnace.getLocation(), 0);
-    }
-
-    private boolean hasPermission(Player p, Integer level) {
-        return p.hasPermission("furnacelevels.upgrade." + level);
-    }
-
-    private List<String> getLangList(String path, Integer lvl) {
-        List<String> lore = new ArrayList<>();
-        for (String s : this.plugin.configs.getLang().getStringList(path)) {
-            if (lvl != null) {
-                int tpt = this.plugin.configs.getConfig().getInt("upgrades.level-" + lvl + ".ticks-per-tick");
-                if (tpt == 0)
-                    tpt++;
-                s = format(s, lvl, tpt);
-            }
-            lore.add(ChatColor.translateAlternateColorCodes('&', s));
-        }
-        return lore;
-    }
-
-    public String getLangMsg(String path, Integer lvl) {
-        if (!this.plugin.configs.getLang().isSet(path))
-            return ChatColor.DARK_RED + "" + ChatColor.BOLD + "Die Nachricht " + path + " fehlt in der lang.yml!";
-        String s = this.plugin.configs.getLang().getString(path);
-        if (lvl != null) {
-            int tpt = this.plugin.configs.getConfig().getInt("upgrades.level-" + lvl + ".ticks-per-tick");
-            if (tpt == 0)
-                tpt++;
-            s = format(s, lvl, tpt);
-        }
-        return ChatColor.translateAlternateColorCodes('&', s);
-    }
-
-    ItemStack createItem(Material material, String name, List<String> lore) {
-        ItemStack item = new ItemStack(material);
-        ItemMeta meta = item.getItemMeta();
-        meta.setDisplayName(name);
-        meta.setLore(lore);
-        item.setItemMeta(meta);
-        return item;
-    }
-
-    private String format(String s, int lvl, int tpt) {
-        s = s.replace("{NEXT-TPT}", Integer.toString(this.plugin.configs.getConfig().getInt("upgrades.level-" + (lvl + 1) + ".ticks-per-tick")));
-        s = s.replace("{TICKS-PER-TICK}", Integer.toString(tpt));
-        s = s.replace("{NEXT-LEVEL}", Integer.toString(lvl + 1));
-        s = s.replace("{LEVEL}", Integer.toString(lvl));
-        s = s.replace("{NEXT-COST}", Double.toString(getCost(lvl + 1)));
-        s = s.replace("{COST}", Double.toString(getCost(lvl)));
-        return s;
-    }
-
-    private ItemStack getItemInHand(Player p) {
-        return p.getInventory().getItemInMainHand();
-    }
-
-    private void burn(Player p, Block b) {
-        p.sendMessage(getLangMsg("burn-msg", null));
-        if (p.getGameMode() != GameMode.CREATIVE)
-            p.damage(0.1D);
-        Location fLoc = b.getLocation();
-        double xDist = (p.getLocation().getX() - fLoc.getX()) * 0.5D;
-        double zDist = (p.getLocation().getZ() - fLoc.getZ()) * 0.5D;
-        Vector direction = new Vector(xDist, 1.0D, zDist).multiply(0.2D);
-        p.setVelocity(direction);
-    }
-}

src/main/java/vpd/bowandaero12/furnacelv/utils/Configs.java

@@ -1,34 +1,28 @@
 package vpd.bowandaero12.furnacelv.utils;
 
-import java.io.File;
-import java.io.IOException;
 import org.apache.commons.io.FileUtils;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import vpd.bowandaero12.furnacelv.FurnaceLevels;
 
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+
 public class Configs {
-  private FurnaceLevels plugin;
+    private final FurnaceLevels plugin;
-  
-  private File furnaceFile;
-  
     private FileConfiguration cfg;
-  
     private FileConfiguration langCfg;
 
-  private FileConfiguration fdata;
-  
     public Configs(FurnaceLevels plugin) {
         this.plugin = plugin;
     }
 
     public void createConfigs() {
         File cfgFile = loadFile("config.yml");
-    this.cfg = loadYaml(cfgFile);
+        this.cfg = YamlConfiguration.loadConfiguration(cfgFile);
         File langFile = loadFile("lang.yml");
-    this.langCfg = loadYaml(langFile);
+        this.langCfg = YamlConfiguration.loadConfiguration(langFile);
-    this.furnaceFile = loadFile("furnaces.yml");
-    this.fdata = loadYaml(this.furnaceFile);
     }
 
     public void createUpdatedConfig() {
@@ -47,45 +41,23 @@ public class Configs {
         return this.langCfg;
     }
 
-  public FileConfiguration getFData() {
-    return this.fdata;
-  }
-  
-  public void saveData() {
-    try {
-      this.fdata.save(this.furnaceFile);
-    } catch (IOException e) {
-      e.printStackTrace();
-    } 
-  }
-  
     private File loadFile(String resource) {
-    File file = new File(this.plugin.getDataFolder(), resource);
+        File file = new File(plugin.getDataFolder(), resource);
         if (!file.exists()) {
             file.getParentFile().mkdirs();
-      this.plugin.saveResource(resource, false);
+            plugin.saveResource(resource, false);
         }
         return file;
     }
 
-  private FileConfiguration loadYaml(File file) {
-    YamlConfiguration yamlConfiguration = new YamlConfiguration();
-    try {
-      yamlConfiguration.load(file);
-    } catch (IOException|org.bukkit.configuration.InvalidConfigurationException e) {
-      e.printStackTrace();
-    } 
-    return (FileConfiguration)yamlConfiguration;
-  }
-  
     private void makeUpdtFile(String resource, String name) {
-    File updtFile = new File(this.plugin.getDataFolder(), name);
+        File updtFile = new File(plugin.getDataFolder(), name);
-    if (!updtFile.exists())
+        if (!updtFile.exists()) {
-      try {
+            try (InputStream in = plugin.getResource(resource)) {
-        updtFile.createNewFile();
+                FileUtils.copyInputStreamToFile(in, updtFile);
-        FileUtils.copyToFile(this.plugin.getResource(resource), updtFile);
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
+    }
 }

src/main/resources/config.yml

@@ -1,15 +1,6 @@
-# Versionsprüfung. Bitte nicht ändern.
+version: '2.1'
-version: '2.0'
-
-# Um benutzerdefinierte Upgrade-Items zu verwenden, muss dies auf 'false' gesetzt werden.
 use-economy: false
-
-# Wenn aktiviert, wird das benutzerdefinierte Ofen-Item nicht gedroppt. Stattdessen wird ein
-# normaler Ofen gedroppt und die Gesamtkosten aller Upgrades werden erstattet.
 refund-cost: false
-
-# Ticks-pro-Tick geben an, wie schnell der Ofen schmilzt.
-# Bestimmte Werte können im Spiel Fehler verursachen. Öfen setzen bei 200 Ticks zurück.
 upgrades:
   level-1:
     cost: 400000
@@ -26,17 +17,10 @@ upgrades:
   level-5:
     cost: 2500000
     ticks-per-tick: 50
-
 item:
-  # Der Materialname muss mit Minecraft 1.21.1 kompatibel sein (z. B. SUNFLOWER).
+  material-type: 'SUNFLOWER'
-  material-type: 'minecraft:sunflower'
   displayname: '&6&lOfen-Upgrade-Token'
-  # Materialdaten sind in Minecraft 1.21.1 veraltet und werden ignoriert.
-  # Dieser Wert wird nicht verwendet, da Datenwerte nicht mehr unterstützt werden.
-  data: 0
   lore:
   - '&cEin spezieller Token, um deinen Ofen zu verbessern!'
-
-# Welten, in denen das Plugin nicht funktioniert.
 world-blacklist:
   - world_end

src/main/resources/plugin.yml

@@ -1,33 +1,71 @@
-main: vpd.bowandaero12.furnacelv.FurnaceLevels
+# Metadaten des Plugins
 name: FurnaceLevels
-version: '2.0'
+version: '2.1'
+main: vpd.bowandaero12.furnacelv.FurnaceLevels
+api-version: 1.20
 author: M_Viper
 description: 'Furnaces go quicker up to level 5!'
-depend: [ProtocolLib]
-soft-depend: [Vault]
-api-version: 1.13
 
+# Abhängigkeiten
+# ProtocolLib wird zwingend benötigt. Das Plugin wird nicht gestartet, wenn es fehlt.
+depend: [ProtocolLib]
+# Vault wird optional benötigt. Das Plugin startet auch ohne Vault.
+softdepend: [Vault]
+
+# Befehle, die das Plugin registriert
 commands:
   fldebug:
-    description: 'Enable or disable debugging'
+    description: 'Aktiviert oder deaktiviert den Debug-Modus'
-    usage: /fldebug
+    usage: '/fldebug'
+    permission: furnacelevels.debug
+  flgive:
+    description: 'Gibt dir oder einem anderen Spieler ein Ofen-Upgrade-Token'
+    usage: '/flgive [Spieler] [Menge]'
+    permission: furnacelevels.give
 
+# Berechtigungen (Permissions)
 permissions:
+  # Eine Eltern-Permission, die alle anderen Berechtigungen dieses Plugins umfasst.
+  furnacelevels.*:
+    description: 'Gibt Zugriff auf alle FurnaceLevels-Funktionen.'
+    children:
+      furnacelevels.give: true
+      furnacelevels.give.other: true
+      furnacelevels.debug: true
+      furnacelevels.upgrade.1: true
+      furnacelevels.upgrade.2: true
+      furnacelevels.upgrade.3: true
+      furnacelevels.upgrade.4: true
+      furnacelevels.upgrade.5: true
+
+  # Berechtigung, um sich selbst Upgrade-Items zu geben
+  furnacelevels.give:
+    description: 'Erlaubt die Verwendung des /flgive Befehls für sich selbst.'
+    default: op
+
+  # Berechtigung, um anderen Spielern Upgrade-Items zu geben
+  furnacelevels.give.other:
+    description: 'Erlaubt die Verwendung des /flgive Befehls für andere Spieler.'
+    default: op
+
+  # Berechtigung, um den Debug-Befehl zu verwenden
+  furnacelevels.debug:
+    description: 'Erlaubt die Verwendung des /fldebug Befehls.'
+    default: op
+
+  # Berechtigungen für die einzelnen Upgrade-Level
   furnacelevels.upgrade.1:
+    description: 'Erlaubt das Upgrade eines Ofens auf Level 1.'
     default: true
-    description: 'Upgrade to level 1'
   furnacelevels.upgrade.2:
-    description: 'Upgrade to level 2'
+    description: 'Erlaubt das Upgrade eines Ofens auf Level 2.'
     default: true
   furnacelevels.upgrade.3:
-    description: 'Upgrade to level 3'
+    description: 'Erlaubt das Upgrade eines Ofens auf Level 3.'
     default: true
   furnacelevels.upgrade.4:
-    description: 'Upgrade to level 4'
+    description: 'Erlaubt das Upgrade eines Ofens auf Level 4.'
     default: true
   furnacelevels.upgrade.5:
-    description: 'Upgrade to level 5'
+    description: 'Erlaubt das Upgrade eines Ofens auf Level 5.'
     default: true
-  furnacelevels.debug:
-    description: 'Use plugin debugging'
-    default: op