commit 78fd8cec2e20ee8af1554dd4c6412b8047bac283 Author: M_Viper Date: Sat Aug 23 01:49:46 2025 +0200 Initial commit diff --git a/README.md b/README.md new file mode 100644 index 0000000..39ed452 --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +"# FurnaceLevels" diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..e3787c7 --- /dev/null +++ b/pom.xml @@ -0,0 +1,113 @@ + + + 4.0.0 + + vpd.bowandaero12 + FurnaceLevels + 2.0 + jar + + FurnaceLevels + Öfen werden bis Stufe 5 schneller! + + + 17 + UTF-8 + + + + + + spigot-repo + https://hub.spigotmc.org/nexus/content/repositories/snapshots/ + + + + jitpack + https://jitpack.io + + + + central + https://repo.maven.apache.org/maven2 + + + + + + + org.spigotmc + spigot-api + 1.21.1-R0.1-SNAPSHOT + provided + + + + com.comphenix.protocol + ProtocolLib + 5.2.0 + system + C:/Users/Viper/Desktop/ProtocolLib.jar + + + + com.github.MilkBowl + VaultAPI + 1.7 + provided + + + + commons-io + commons-io + 2.11.0 + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.13.0 + + ${java.version} + ${java.version} + + + + + org.apache.maven.plugins + maven-shade-plugin + 3.5.3 + + + package + + shade + + + false + + + + + + + + + src/main/resources + true + + plugin.yml + config.yml + lang.yml + furnaces.yml + + + + + \ No newline at end of file diff --git a/src/main/java/vpd/bowandaero12/furnacelv/FurnaceLevels.java b/src/main/java/vpd/bowandaero12/furnacelv/FurnaceLevels.java new file mode 100644 index 0000000..df1bc68 --- /dev/null +++ b/src/main/java/vpd/bowandaero12/furnacelv/FurnaceLevels.java @@ -0,0 +1,77 @@ +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.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 { + 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); + + public void onEnable() { + PluginManager pm = getServer().getPluginManager(); + this.protocolManager = ProtocolLibrary.getProtocolManager(); + this.configs.createConfigs(); + boolean useEco = true; + if (this.configs.getConfig().isSet("use-economy")) + useEco = this.configs.getConfig().getBoolean("use-economy"); + if (useEco && setupEconomy()) { + log.info(String.format("[%s] " + this.vaultEco.getName() + " has been detected and is in use!", new Object[] { getDescription().getName() })); + } else { + log.info(String.format("[%s] Using custom items for furnace upgrades.", new Object[] { 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() {} + + private void checkVer(String ver) { + if (!this.configs.getConfig().isSet("version") || !this.configs.getConfig().getString("version").equals(ver)) { + 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(); + } + 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() })); + this.configs.createUpdatedLang(); + } + } + + private boolean setupEconomy() { + RegisteredServiceProvider rsp = getServer().getServicesManager().getRegistration(Economy.class); + if (rsp == null) + return false; + this.vaultEco = (Economy)rsp.getProvider(); + return (this.vaultEco != null); + } +} diff --git a/src/main/java/vpd/bowandaero12/furnacelv/commands/DebugCmd.java b/src/main/java/vpd/bowandaero12/furnacelv/commands/DebugCmd.java new file mode 100644 index 0000000..222dca7 --- /dev/null +++ b/src/main/java/vpd/bowandaero12/furnacelv/commands/DebugCmd.java @@ -0,0 +1,44 @@ +package vpd.bowandaero12.furnacelv.commands; + +import java.util.HashSet; +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 { + private FurnaceLevels plugin; + + private Set debugging; + + public DebugCmd(FurnaceLevels plugin) { + this.debugging = new HashSet<>(); + this.plugin = plugin; + } + + public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) { + if (!(sender instanceof Player)) + return true; + 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 getDebugging() { + return this.debugging; + } +} diff --git a/src/main/java/vpd/bowandaero12/furnacelv/events/FurnaceEvent.java b/src/main/java/vpd/bowandaero12/furnacelv/events/FurnaceEvent.java new file mode 100644 index 0000000..be6eef4 --- /dev/null +++ b/src/main/java/vpd/bowandaero12/furnacelv/events/FurnaceEvent.java @@ -0,0 +1,176 @@ +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.Material; +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.Listener; +import org.bukkit.event.inventory.FurnaceBurnEvent; +import org.bukkit.event.inventory.FurnaceSmeltEvent; +import org.bukkit.scheduler.BukkitRunnable; +import org.bukkit.util.BlockVector; +import vpd.bowandaero12.furnacelv.FurnaceLevels; +import vpd.bowandaero12.furnacelv.utils.Fuels; + +public class FurnaceEvent implements Listener { + + private FurnaceLevels plugin; + private Class craftPlayer; + private Method getHandle; + + private static List boosted = new ArrayList<>(); + + public FurnaceEvent(FurnaceLevels plugin) { + this.plugin = plugin; + } + + @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())); + } + } + + @EventHandler + public void onFurnace(FurnaceBurnEvent event) { + if (this.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())); + } + } + + private short getTicks(Integer level) { + if (level == 0) return 0; + return (short) this.plugin.configs.getConfig() + .getInt("upgrades.level-" + level + ".ticks-per-tick"); + } + + private void runFurnace(final Block block, final Material burning, int level) { + final short speedUp = getTicks(level); + if (speedUp == 0) return; + + 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; + } + + 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 (!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; + } + + 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)); + + 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(2, fraction); + + plugin.protocolManager.sendServerPacket(player, max); + plugin.protocolManager.sendServerPacket(player, current); + } + + } else { + boosted.remove(block.getLocation().toVector().toBlockVector()); + cancel(); + } + } + }.runTaskTimer(this.plugin, 1L, 1L); + } + } + + private String getServerVersion() { + try { + return Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3]; + } catch (ArrayIndexOutOfBoundsException err) { + return "unknown"; + } + } + + public void setValues() { + try { + this.craftPlayer = Class.forName("org.bukkit.craftbukkit." + getServerVersion() + ".entity.CraftPlayer"); + this.getHandle = craftPlayer.getMethod("getHandle"); + } catch (ClassNotFoundException | NoSuchMethodException err) { + err.printStackTrace(); + } + } + + private int getBurnTime(Material material) { + return Fuels.fromString(material.toString()).getDuration(); + } +} diff --git a/src/main/java/vpd/bowandaero12/furnacelv/items/ItemHandler.java b/src/main/java/vpd/bowandaero12/furnacelv/items/ItemHandler.java new file mode 100644 index 0000000..adfd3cd --- /dev/null +++ b/src/main/java/vpd/bowandaero12/furnacelv/items/ItemHandler.java @@ -0,0 +1,206 @@ +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 furnaceTrack; + + public ItemHandler(FurnaceLevels plugin) { + this.furnaceTrack = new HashMap<>(); + this.plugin = plugin; + } + + public Map 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 lore = item.getItemMeta().getLore(); + List 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 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 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 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 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 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(); + } +} diff --git a/src/main/java/vpd/bowandaero12/furnacelv/items/LevelMenu.java b/src/main/java/vpd/bowandaero12/furnacelv/items/LevelMenu.java new file mode 100644 index 0000000..8016965 --- /dev/null +++ b/src/main/java/vpd/bowandaero12/furnacelv/items/LevelMenu.java @@ -0,0 +1,268 @@ +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 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 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 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 getLangList(String path, Integer lvl) { + List 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 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); + } +} \ No newline at end of file diff --git a/src/main/java/vpd/bowandaero12/furnacelv/utils/Configs.java b/src/main/java/vpd/bowandaero12/furnacelv/utils/Configs.java new file mode 100644 index 0000000..3cfe2df --- /dev/null +++ b/src/main/java/vpd/bowandaero12/furnacelv/utils/Configs.java @@ -0,0 +1,91 @@ +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; + +public class Configs { + private 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); + File langFile = loadFile("lang.yml"); + this.langCfg = loadYaml(langFile); + this.furnaceFile = loadFile("furnaces.yml"); + this.fdata = loadYaml(this.furnaceFile); + } + + public void createUpdatedConfig() { + makeUpdtFile("config.yml", "new-config.yml"); + } + + public void createUpdatedLang() { + makeUpdtFile("lang.yml", "new-lang.yml"); + } + + public FileConfiguration getConfig() { + return this.cfg; + } + + public FileConfiguration getLang() { + 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); + if (!file.exists()) { + file.getParentFile().mkdirs(); + this.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); + if (!updtFile.exists()) + try { + updtFile.createNewFile(); + FileUtils.copyToFile(this.plugin.getResource(resource), updtFile); + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/src/main/java/vpd/bowandaero12/furnacelv/utils/Fuels.java b/src/main/java/vpd/bowandaero12/furnacelv/utils/Fuels.java new file mode 100644 index 0000000..b112248 --- /dev/null +++ b/src/main/java/vpd/bowandaero12/furnacelv/utils/Fuels.java @@ -0,0 +1,233 @@ +package vpd.bowandaero12.furnacelv.utils; + +import java.util.HashMap; +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; + +public enum Fuels { + BLACK_STAINED_GLASS_PANE("BLACK_STAINED_GLASS_PANE", 15), + LAVA_BUCKET("LAVA_BUCKET", 20000), + COAL_BLOCK("COAL_BLOCK", 16000), + DRIED_KELP_BLOCK("DRIED_KELP_BLOCK", 4000), + BLAZE_ROD("BLAZE_ROD", 2400), + COAL("COAL", 1600), + CHARCOAL("CHARCOAL", 1600), + OAK_BOAT("OAK_BOAT", 400), + BIRCH_BOAT("BIRCH_BOAT", 400), + ACACIA_BOAT("ACACIA_BOAT", 400), + JUNGLE_BOAT("JUNGLE_BOAT", 400), + SPRUCE_BOAT("SPRUCE_BOAT", 400), + DARK_OAK_BOAT("DARK_OAK_BOAT", 400), + OAK_LOG("OAK_LOG", 300), + SPRUCE_LOG("SPRUCE_LOG", 300), + BIRCH_LOG("BIRCH_LOG", 300), + JUNGLE_LOG("JUNGLE_LOG", 300), + ACACIA_LOG("ACACIA_LOG", 300), + DARK_OAK_LOG("DARK_OAK_LOG", 300), + OAK_WOOD("OAK_WOOD", 300), + SPRUCE_WOOD("SPRUCE_WOOD", 300), + BIRCH_WOOD("BIRCH_WOOD", 300), + JUNGLE_WOOD("JUNGLE_WOOD", 300), + ACACIA_WOOD("ACACIA_WOOD", 300), + DARK_OAK_WOOD("DARK_OAK_WOOD", 300), + OAK_PRESSURE_PLATE("OAK_PRESSURE_PLATE", 300), + SPRUCE_PRESSURE_PLATE("SPRUCE_PRESSURE_PLATE", 300), + BIRCH_PRESSURE_PLATE("BIRCH_PRESSURE_PLATE", 300), + JUNGLE_PRESSURE_PLATE("JUNGLE_PRESSURE_PLATE", 300), + ACACIA_PRESSURE_PLATE("ACACIA_PRESSURE_PLATE", 300), + DARK_OAK_PRESSURE_PLATE("DARK_OAK_PRESSURE_PLATE", 300), + OAK_FENCE("OAK_FENCE", 300), + BIRCH_FENCE("BIRCH_FENCE", 300), + ACACIA_FENCE("ACACIA_FENCE", 300), + SPRUCE_FENCE("SPRUCE_FENCE", 300), + JUNGLE_FENCE("JUNGLE_FENCE", 300), + DARK_OAK_FENCE("DARK_OAK_FENCE", 300), + OAK_FENCE_GATE("OAK_FENCE_GATE", 300), + BIRCH_FENCE_GATE("BIRCH_FENCE_GATE", 300), + JUNGLE_FENCE_GATE("JUNGLE_FENCE_GATE", 300), + ACACIA_FENCE_GATE("ACACIA_FENCE_GATE", 300), + SPRUCE_FENCE_GATE("SPRUCE_FENCE_GATE", 300), + DARK_OAK_FENCE_GATE("DARK_OAK_FENCE_GATE", 300), + OAK_STAIRS("OAK_STAIRS", 300), + BIRCH_STAIRS("BIRCH_STAIRS", 300), + SPRUCE_STAIRS("SPRUCE_STAIRS", 300), + JUNGLE_STAIRS("JUNGLE_STAIRS", 300), + DARK_OAK_STAIRS("DARK_OAK_STAIRS", 300), + ACACIA_STAIRS("ACACIA_STAIRS", 300), + OAK_TRAPDOOR("OAK_TRAPDOOR", 300), + SPRUCE_TRAPDOOR("SPRUCE_TRAPDOOR", 300), + BIRCH_TRAPDOOR("BIRCH_TRAPDOOR", 300), + JUNGLE_TRAPDOOR("JUNGLE_TRAPDOOR", 300), + ACACIA_TRAPDOOR("ACACIA_TRAPDOOR", 300), + DARK_OAK_TRAPDOOR("DARK_OAK_TRAPDOOR", 300), + CRAFTING_TABLE("CRAFTING_TABLE", 300), + BOOKSHELF("BOOKSHELF", 300), + CHEST("CHEST", 300), + TRAPPED_CHEST("TRAPPED_CHEST", 300), + DAYLIGHT_DETECTOR("DAYLIGHT_DETECTOR", 300), + JUKEBOX("JUKEBOX", 300), + NOTE_BLOCK("NOTE_BLOCK", 300), + BROWN_MUSHROOM_BLOCK("BROWN_MUSHROOM_BLOCK", 300), + RED_MUSHROOM_BLOCK("RED_MUSHROOM_BLOCK", 300), + BLACK_BANNER("BLACK_BANNER", 300), + RED_BANNER("RED_BANNER", 300), + GREEN_BANNER("GREEN_BANNER", 300), + BROWN_BANNER("BROWN_BANNER", 300), + PURPLE_BANNER("PURPLE_BANNER", 300), + CYAN_BANNER("CYAN_BANNER", 300), + LIGHT_GRAY_BANNER("LIGHT_GRAY_BANNER", 300), + GRAY_BANNER("GRAY_BANNER", 300), + PINK_BANNER("PINK_BANNER", 300), + LIME_BANNER("LIME_BANNER", 300), + BLUE_BANNER("BLUE_BANNER", 300), + LIGHT_BLUE_BANNER("LIGHT_BLUE_BANNER", 300), + MAGENTA_BANNER("MAGENTA_BANNER", 300), + ORANGE_BANNER("ORANGE_BANNER", 300), + WHITE_BANNER("WHITE_BANNER", 300), + BOW("BOW", 300), + FISHING_ROD("FISHING_ROD", 300), + LADDER("LADDER", 300), + WOODEN_SHOVEL("WOODEN_SHOVEL", 200), + WOODEN_HOE("WOODEN_HOE", 200), + WOODEN_AXE("WOODEN_AXE", 200), + WOODEN_SWORD("WOODEN_SWORD", 200), + SIGN("SIGN", 200), + OAK_DOOR("OAK_DOOR", 200), + SPRUCE_DOOR("SPRUCE_DOOR", 200), + BIRCH_DOOR("BIRCH_DOOR", 200), + JUNGLE_DOOR("JUNGLE_DOOR", 200), + ACACIA_DOOR("ACACIA_DOOR", 200), + DARK_OAK_DOOR("DARK_OAK_DOOR", 200), + WOODEN_PICKAXE("WOODEN_PICKAXE", 200), + OAK_SLAB("OAK_SLAB", 150), + SPRUCE_SLAB("SPRUCE_SLAB", 150), + BIRCH_SLAB("BIRCH_SLAB", 150), + JUNGLE_SLAB("JUNGLE_SLAB", 150), + ACACIA_SLAB("ACACIA_SLAB", 150), + DARK_OAK_SLAB("DARK_OAK_SLAB", 150), + BOWL("BOWL", 100), + STICK("STICK", 100), + OAK_BUTTON("OAK_BUTTON", 100), + SPRUCE_BUTTON("SPRUCE_BUTTON", 100), + BIRCH_BUTTON("BIRCH_BUTTON", 100), + JUNGLE_BUTTON("JUNGLE_BUTTON", 100), + ACACIA_BUTTON("ACACIA_BUTTON", 100), + DARK_OAK_BUTTON("DARK_OAK_BUTTON", 100), + OAK_SAPLING("OAK_SAPLING", 100), + SPRUCE_SAPLING("SPRUCE_SAPLING", 100), + BIRCH_SAPLING("BIRCH_SAPLING", 100), + JUNGLE_SAPLING("JUNGLE_SAPLING", 100), + ACACIA_SAPLING("ACACIA_SAPLING", 100), + DARK_OAK_SAPLING("DARK_OAK_SAPLING", 100), + WHITE_WOOL("WHITE_WOOL", 100), + ORANGE_WOOL("ORANGE_WOOL", 100), + MAGENTA_WOOL("MAGENTA_WOOL", 100), + LIGHT_BLUE_WOOL("LIGHT_BLUE_WOOL", 100), + YELLOW_WOOL("YELLOW_WOOL", 100), + LIME_WOOL("LIME_WOOL", 100), + PINK_WOOL("PINK_WOOL", 100), + GRAY_WOOL("GRAY_WOOL", 100), + LIGHT_GRAY_WOOL("LIGHT_GRAY_WOOL", 100), + CYAN_WOOL("CYAN_WOOL", 100), + PURPLE_WOOL("PURPLE_WOOL", 100), + BLUE_WOOL("BLUE_WOOL", 100), + BROWN_WOOL("BROWN_WOOL", 100), + GREEN_WOOL("GREEN_WOOL", 100), + RED_WOOL("RED_WOOL", 100), + BLACK_WOOL("BLACK_WOOL", 100), + WHITE_CARPET("WHITE_CARPET", 67), + ORANGE_CARPET("ORANGE_CARPET", 67), + MAGENTA_CARPET("MAGENTA_CARPET", 67), + LIGHT_BLUE_CARPET("LIGHT_BLUE_CARPET", 67), + YELLOW_CARPET("YELLOW_CARPET", 67), + LIME_CARPET("LIME_CARPET", 67), + PINK_CARPET("PINK_CARPET", 67), + GRAY_CARPET("GRAY_CARPET", 67), + LIGHT_GRAY_CARPET("LIGHT_GRAY_CARPET", 67), + CYAN_CARPET("CYAN_CARPET", 67), + PURPLE_CARPET("PURPLE_CARPET", 67), + BLUE_CARPET("BLUE_CARPET", 67), + BROWN_CARPET("BROWN_CARPET", 67), + GREEN_CARPET("GREEN_CARPET", 67), + RED_CARPET("RED_CARPET", 67), + BLACK_CARPET("BLACK_CARPET", 67); + + String material; + int duration; + + static HashMap cachedSearch; + + Fuels(String material, int duration) { + this.material = material; + this.duration = duration; + } + + public int getDuration() { + return this.duration; + } + + public ItemStack parseItem() { + Material mat = Material.matchMaterial(this.material); + return new ItemStack(mat); + } + + public static boolean isNewVersion() { + return true; // Immer true für 1.21 + } + + public static Fuels requestFuel(String name, byte data) { + if (cachedSearch.containsKey(name.toUpperCase())) + return cachedSearch.get(name.toUpperCase()); + for (Fuels mat : values()) { + if (name.toUpperCase().equals(mat.material)) { + cachedSearch.put(mat.material, mat); + return mat; + } + } + return null; + } + + public boolean isSameMaterial(ItemStack comp) { + return comp.getType() == parseMaterial(); + } + + public Fuels fromMaterial(Material mat) { + try { + return valueOf(mat.toString()); + } catch (IllegalArgumentException e) { + for (Fuels fuel : values()) { + if (fuel.material.equals(mat.toString())) + return fuel; + } + return null; + } + } + + public static Fuels fromString(String key) { + try { + return valueOf(key); + } catch (IllegalArgumentException e) { + return requestFuel(key, (byte) 0); + } + } + + public boolean isDamageable(Fuels type) { + switch (type.toString()) { + case "WOODEN_SWORD": + case "WOODEN_AXE": + case "WOODEN_PICKAXE": + case "WOODEN_SHOVEL": + case "WOODEN_HOE": + return true; + } + return false; + } + + public Material parseMaterial() { + return Material.matchMaterial(this.material); + } + + static { + cachedSearch = new HashMap<>(); + } +} \ No newline at end of file diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml new file mode 100644 index 0000000..5e7948d --- /dev/null +++ b/src/main/resources/config.yml @@ -0,0 +1,42 @@ +# Versionsprüfung. Bitte nicht ändern. +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 + ticks-per-tick: 10 + level-2: + cost: 700000 + ticks-per-tick: 20 + level-3: + cost: 1200000 + ticks-per-tick: 30 + level-4: + cost: 1800000 + ticks-per-tick: 40 + level-5: + cost: 2500000 + ticks-per-tick: 50 + +item: + # Der Materialname muss mit Minecraft 1.21.1 kompatibel sein (z. B. 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 \ No newline at end of file diff --git a/src/main/resources/furnaces.yml b/src/main/resources/furnaces.yml new file mode 100644 index 0000000..e69de29 diff --git a/src/main/resources/lang.yml b/src/main/resources/lang.yml new file mode 100644 index 0000000..32dca76 --- /dev/null +++ b/src/main/resources/lang.yml @@ -0,0 +1,75 @@ +# Nicht ändern +version: '2.0' + +############################################## + +# Aktuelle Platzhalter: +# {TICKS-PER-TICK} - Die Ticks-pro-Tick aus der Konfiguration. 1 bei Stufe 0. +# {NEXT-TPT} - Die Ticks-pro-Tick für die nächste Stufe. +# {LEVEL} - Die aktuelle Stufe des Furnace. +# {NEXT-LEVEL} - Die nächste Stufe des Furnace. +# {COST} - Die Kosten für das aktuelle Furnace-Upgrade. +# {NEXT-COST} - Die Kosten für das nächste Furnace-Upgrade. + +level-gui: + name: '&eFurnace auf Stufe {NEXT-LEVEL} verbessern?' + max-level-name: '&eStufe 5 Furnace' + items: + book: + name: '&5&lFurnace-Statistiken' + lore: + - '&9Geschwindigkeit: &e{TICKS-PER-TICK}x' + - '&9Stufe: &e{LEVEL}' + emerald-block: + name: '&aJa' + lore: + - '&5Furnace auf Stufe {NEXT-LEVEL} verbessern' + - '&5für {NEXT-COST}?' + - '&6Nächstes Upgrade: &e{NEXT-TPT}x Geschwindigkeit' + redstone-block: + name: '&cNein' + lore: + - '&5Menü schließen.' + obsidian: + name: '&4Maximale Stufe!' + lore: + - '&cDein Furnace ist vollständig verbessert!' + +############################################## + +# Dieser Abschnitt dient der Anpassung der Namen und Beschreibungen +# von verbesserten Furnaces. Namen und Beschreibungen mit dem '&'-Zeichen +# müssen in einfache Anführungszeichen (' ') gesetzt werden. + +# Keine Beschreibung kann gesetzt werden, indem der 'lore:'-Abschnitt +# komplett entfernt wird. Das Format für eine String-Liste (wie lore) ist: - '(Text)' +# - '(Text)' + +level-1: + name: '&7Level 1 Furnace' + lore: +level-2: + name: '&fLevel 2 Furnace' + lore: +level-3: + name: '&aLevel 3 Furnace' + lore: +level-4: + name: '&9Level 4 Furnace' + lore: +level-5: + name: '&5Level 5 Furnace' + lore: + +############################################## + +# Allgemeine Standardnachrichten +burn-msg: '&cDu kannst brennende Öfen nicht verbessern!' +error-msg: '&cFehler! Bitte versuche es erneut.' +no-level-permission: '&cDu kannst Öfen nicht auf diese Stufe verbessern!' +no-permission: '&cDu hast keine Berechtigung, dies zu tun!' +debug-enabled: '&aDebug-Modus aktiviert!' +debug-disabled: '&cDebug-Modus deaktiviert.' +not-enough-money: '&cDu kannst dir das nicht leisten!' +successful-purchase: '&aKauf erfolgreich!' +furnace-placed: '&aStufe {LEVEL} Ofen platziert!' \ No newline at end of file diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..c03c93e --- /dev/null +++ b/src/main/resources/plugin.yml @@ -0,0 +1,33 @@ +main: vpd.bowandaero12.furnacelv.FurnaceLevels +name: FurnaceLevels +version: '2.0' +author: M_Viper +description: 'Furnaces go quicker up to level 5!' +depend: [ProtocolLib] +soft-depend: [Vault] +api-version: 1.13 + +commands: + fldebug: + description: 'Enable or disable debugging' + usage: /fldebug + +permissions: + furnacelevels.upgrade.1: + default: true + description: 'Upgrade to level 1' + furnacelevels.upgrade.2: + description: 'Upgrade to level 2' + default: true + furnacelevels.upgrade.3: + description: 'Upgrade to level 3' + default: true + furnacelevels.upgrade.4: + description: 'Upgrade to level 4' + default: true + furnacelevels.upgrade.5: + description: 'Upgrade to level 5' + default: true + furnacelevels.debug: + description: 'Use plugin debugging' + default: op \ No newline at end of file