M_Viper/FurnaceLevels
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Initial commit

Browse Source
This commit is contained in:
M_Viper
2025-08-23 01:49:46 +02:00
commit 78fd8cec2e
13 changed files with 1359 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
README.md Normal file
View File

@@ -0,0 +1 @@
"# FurnaceLevels"

113
pom.xml Normal file
View File

@@ -0,0 +1,113 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>vpd.bowandaero12</groupId>
<artifactId>FurnaceLevels</artifactId>
<version>2.0</version>
<packaging>jar</packaging>
<name>FurnaceLevels</name>
<description>Öfen werden bis Stufe 5 schneller!</description>
<properties>
<java.version>17</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<repositories>
<!-- Spigot-Repository -->
<repository>
<id>spigot-repo</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
</repository>
<!-- JitPack-Repository (für Vault) -->
<repository>
<id>jitpack</id>
<url>https://jitpack.io</url>
</repository>
<!-- Maven Central (für Apache Commons IO und andere Abhängigkeiten) -->
<repository>
<id>central</id>
<url>https://repo.maven.apache.org/maven2</url>
</repository>
</repositories>
<dependencies>
<!-- Spigot-API -->
<dependency>
<groupId>org.spigotmc</groupId>
<artifactId>spigot-api</artifactId>
<version>1.21.1-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<!-- ProtocolLib (lokale JAR-Datei) -->
<dependency>
<groupId>com.comphenix.protocol</groupId>
<artifactId>ProtocolLib</artifactId>
<version>5.2.0</version>
<scope>system</scope>
<systemPath>C:/Users/Viper/Desktop/ProtocolLib.jar</systemPath>
</dependency>
<!-- Vault -->
<dependency>
<groupId>com.github.MilkBowl</groupId>
<artifactId>VaultAPI</artifactId>
<version>1.7</version>
<scope>provided</scope>
</dependency>
<!-- Apache Commons IO (für FileUtils in Configs.java) -->
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.11.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- Maven Compiler Plugin -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.13.0</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
<!-- Maven Shade Plugin (für das Einbinden von Abhängigkeiten wie Apache Commons IO) -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.5.3</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<createDependencyReducedPom>false</createDependencyReducedPom>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
<resources>
<!-- Einbinden von plugin.yml und anderen Ressourcen -->
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
<includes>
<include>plugin.yml</include>
<include>config.yml</include>
<include>lang.yml</include>
<include>furnaces.yml</include>
</includes>
</resource>
</resources>
</build>
</project>

77
src/main/java/vpd/bowandaero12/furnacelv/FurnaceLevels.java Normal file
View File

@@ -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<Economy> rsp = getServer().getServicesManager().getRegistration(Economy.class);
if (rsp == null)
return false;
this.vaultEco = (Economy)rsp.getProvider();
return (this.vaultEco != null);
}
}

44
src/main/java/vpd/bowandaero12/furnacelv/commands/DebugCmd.java Normal file
View File

@@ -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<UUID> 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<UUID> getDebugging() {
return this.debugging;
}
}

176
src/main/java/vpd/bowandaero12/furnacelv/events/FurnaceEvent.java Normal file
View File

@@ -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<BlockVector> 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();
}
}

206
src/main/java/vpd/bowandaero12/furnacelv/items/ItemHandler.java Normal file
View File

@@ -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<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();
}
}

268
src/main/java/vpd/bowandaero12/furnacelv/items/LevelMenu.java Normal file
View File

@@ -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<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);
}
}

91
src/main/java/vpd/bowandaero12/furnacelv/utils/Configs.java Normal file
View File

@@ -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();
}
}
}

233
src/main/java/vpd/bowandaero12/furnacelv/utils/Fuels.java Normal file
View File

@@ -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<String, Fuels> 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<>();
}
}

42
src/main/resources/config.yml Normal file
View File

@@ -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

0
src/main/resources/furnaces.yml Normal file
View File

75
src/main/resources/lang.yml Normal file
View File

@@ -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!'

33
src/main/resources/plugin.yml Normal file
View File

@@ -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