diff --git a/src/main/java/vpd/bowandaero12/furnacelv/events/FurnaceEvent.java b/src/main/java/vpd/bowandaero12/furnacelv/events/FurnaceEvent.java index be6eef4..72bb1a3 100644 --- a/src/main/java/vpd/bowandaero12/furnacelv/events/FurnaceEvent.java +++ b/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 Class craftPlayer; + private final FurnaceLevels plugin; + private final NamespacedKey furnaceLevelKey; + private final NamespacedKey menuKey; private Method getHandle; - - private static List boosted = new ArrayList<>(); + private static final List 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(); - if (furnace.getInventory().getFuel() != null && - this.plugin.itemhandler.getFurnaceTrack().get(block.getLocation()) != null) { - runFurnace(block, furnace.getInventory().getFuel().getType(), - this.plugin.itemhandler.getFurnaceTrack().get(block.getLocation())); + int level = getFurnaceLevel(block); + if (level > 0 && event.getSource().getType() != Material.AIR) { + runFurnace(block, event.getSource().getType(), level); } } @EventHandler public void onFurnace(FurnaceBurnEvent event) { - if (this.plugin.configs.getLang().getStringList("world-blacklist") - .contains(event.getBlock().getWorld().getName())) return; + if (plugin.configs.getLang().getStringList("world-blacklist").contains(event.getBlock().getWorld().getName())) return; Block block = event.getBlock(); - if (this.plugin.itemhandler.getFurnaceTrack().get(block.getLocation()) != null) { - runFurnace(block, event.getFuel().getType(), - this.plugin.itemhandler.getFurnaceTrack().get(block.getLocation())); + int level = getFurnaceLevel(block); + if (level > 0) { + 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() - .getInt("upgrades.level-" + level + ".ticks-per-tick"); + return (short) plugin.configs.getConfig().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 { - furnace = (Furnace) block.getState(); - } catch (ClassCastException e) { - cancel(); - return; - } + try { furnace = (Furnace) block.getState(); } + 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; - } - furnace.setBurnTime(burnTime); - furnace.update(); + if (burnTime < 0) { 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 = -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; - } - + int windowID = getWindowId(player); 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); - int fraction = burnTime * 100 / getBurnTime(burning); + current.getIntegers().write(0, windowID); current.getIntegers().write(1, 0); + int fraction = (burnTime * 100) / getBurnTime(burning); current.getIntegers().write(2, fraction); - plugin.protocolManager.sendServerPacket(player, max); - plugin.protocolManager.sendServerPacket(player, current); + try { plugin.protocolManager.sendServerPacket(player, max); 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(this.plugin, 1L, 1L); + }.runTaskTimer(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]; - } catch (ArrayIndexOutOfBoundsException err) { - return "unknown"; - } + Object entityPlayer = getHandle.invoke(player); + for (java.lang.reflect.Field field : entityPlayer.getClass().getSuperclass().getDeclaredFields()) { + 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) { - err.printStackTrace(); + } catch (Exception err) { + 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 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); } } }