diff --git a/.classpath b/.classpath index a5d9509..234db15 100644 --- a/.classpath +++ b/.classpath @@ -18,7 +18,7 @@ - + diff --git a/.gitignore b/.gitignore index b83d222..4a9e9ef 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,5 @@ /target/ +/bin/ +.gitignore +.classpath +.project diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs index 2f5cc74..b5490a0 100644 --- a/.settings/org.eclipse.jdt.core.prefs +++ b/.settings/org.eclipse.jdt.core.prefs @@ -1,8 +1,8 @@ eclipse.preferences.version=1 -org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 -org.eclipse.jdt.core.compiler.compliance=1.8 +org.eclipse.jdt.core.compiler.codegen.targetPlatform=11 +org.eclipse.jdt.core.compiler.compliance=11 org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore -org.eclipse.jdt.core.compiler.release=disabled -org.eclipse.jdt.core.compiler.source=1.8 +org.eclipse.jdt.core.compiler.release=enabled +org.eclipse.jdt.core.compiler.source=11 diff --git a/bin/pom.xml b/bin/pom.xml index 04b6cde..678c043 100644 --- a/bin/pom.xml +++ b/bin/pom.xml @@ -50,6 +50,10 @@ destroystokyo-repo https://repo.destroystokyo.com/repository/maven-public/ + + brokkonaut + https://www.iani.de/nexus/content/groups/public + diff --git a/pom.xml b/pom.xml index d268225..413ad7b 100644 --- a/pom.xml +++ b/pom.xml @@ -1,53 +1,62 @@ - - 4.0.0 - net.brennholz.challenges - Challenges - 2.0 - + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + 4.0.0 + de.fanta.challenges + Challenges + 1.16.1.2-DEV + UTF-8 - UTF-8 - UTF-8 - UTF-8 - - - - destroystokyo-repo - https://repo.destroystokyo.com/repository/maven-public/ - - - - - com.destroystokyo.paper - paper-api - 1.15.2-R0.1-SNAPSHOT - provided - - - - - - org.apache.maven.plugins - maven-jar-plugin - 3.2.0 - - ${project.artifactId} - - - - maven-compiler-plugin - 3.8.1 - + UTF-8 + ${project.groupId}.Challenges + fanta, vollkorntomate + + + + destroystokyo-repo + https://repo.destroystokyo.com/repository/maven-public/ + + + brokkonaut + https://www.iani.de/nexus/content/groups/public + + + + + com.destroystokyo.paper + paper-api + 1.16.1-R0.1-SNAPSHOT + provided + + + de.iani.cubeside + CubesideUtilsBukkit + 1.16-SNAPSHOT + provided + + + + + + org.apache.maven.plugins + maven-jar-plugin + 3.2.0 + + ${project.artifactId}-${project.version} + + + + maven-compiler-plugin + 3.8.1 + 11 - - - - - - src/main/resources - true - - - + + + + + + src/main/resources + true + + + diff --git a/src/main/java/de/fanta/challenges/Challenges.java b/src/main/java/de/fanta/challenges/Challenges.java new file mode 100644 index 0000000..1262148 --- /dev/null +++ b/src/main/java/de/fanta/challenges/Challenges.java @@ -0,0 +1,277 @@ +/*TODO +Backpack Reset +Gamerule Buttons +*/ + +package de.fanta.challenges; + +import de.fanta.challenges.challenges.RandomDrops; +import de.fanta.challenges.scoreboard.ScoreBoardManager; +import de.fanta.challenges.commands.CommandRegistration; +import de.fanta.challenges.events.PlayerCountChangedEvent; +import de.fanta.challenges.events.ServerStatusChangedEvent; +import de.fanta.challenges.events.TimerChangedEvent; +import de.fanta.challenges.guis.BackpackGui; +import de.fanta.challenges.guis.ResetGui; +import de.fanta.challenges.guis.TimerGui; +import de.fanta.challenges.guis.settingsgui.MainGui; +import de.fanta.challenges.guis.settingsgui.OtherSettingsGui; +import de.fanta.challenges.guis.settingsgui.ServerSettingsGui; +import de.fanta.challenges.guis.settingsgui.SettingsGui; +import de.fanta.challenges.listeners.BlockCreateListener; +import de.fanta.challenges.listeners.BlockDestroyListener; +import de.fanta.challenges.listeners.DamageListener; +import de.fanta.challenges.listeners.DeathListener; +import de.fanta.challenges.listeners.InteractListener; +import de.fanta.challenges.listeners.InventoryClickListener; +import de.fanta.challenges.listeners.PlayerListener; +import de.fanta.challenges.listeners.QuitJoinListener; +import de.fanta.challenges.scoreboard.ScoreManager; +import de.fanta.challenges.utils.ChatUtil; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.BanList; +import org.bukkit.Bukkit; +import org.bukkit.GameRule; +import org.bukkit.Material; +import org.bukkit.World; +import org.bukkit.WorldCreator; +import org.bukkit.WorldType; +import org.bukkit.configuration.InvalidConfigurationException; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import org.bukkit.plugin.java.JavaPlugin; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; + +public class Challenges extends JavaPlugin { + private static Challenges plugin; + + private File backpackConfigFile; + + private FileConfiguration BackpackConfig; + + private File RndDropsConfigFile; + + private FileConfiguration RndDropsConfig; + + private Timer timer; + + private BackpackGui backpack; + + private ScoreBoardManager sbManager; + private ScoreManager scoreManager; + + public RandomDrops rndDrops; + + public static Challenges getPlugin() { + return plugin; + } + + public static final String PREFIX = ChatColor.of("#455aad") + "[" + ChatUtil.NORMAL + "Challenge" + ChatColor.of("#455aad") + "]"; + public static final String GUIPREFIX = ChatColor.of("#2d8745") + "Challenge"; + + private Player currentEditor; + + private boolean waitingForShutdown; + + @Override + public void onEnable() { + plugin = this; + + this.timer = new Timer(this); + this.rndDrops = new RandomDrops(); + + this.scoreManager = new ScoreManager(this); + + this.backpack = new BackpackGui(getConfig().getInt("backpack_size") * 9); + + new CommandRegistration(this).registerCommands(); + + Bukkit.getPluginManager().registerEvents(new InventoryClickListener(), this); + Bukkit.getPluginManager().registerEvents(new QuitJoinListener(), this); + Bukkit.getPluginManager().registerEvents(new BlockDestroyListener(), this); + Bukkit.getPluginManager().registerEvents(new BlockCreateListener(), this); + Bukkit.getPluginManager().registerEvents(new InteractListener(), this); + Bukkit.getPluginManager().registerEvents(new DamageListener(), this); + Bukkit.getPluginManager().registerEvents(new DeathListener(), this); + Bukkit.getPluginManager().registerEvents(new PlayerListener(), this); + Bukkit.getPluginManager().registerEvents(new TimerGui(), this); + Bukkit.getPluginManager().registerEvents(new ResetGui(), this); + Bukkit.getPluginManager().registerEvents(new MainGui(), this); + Bukkit.getPluginManager().registerEvents(new SettingsGui(), this); + Bukkit.getPluginManager().registerEvents(new ServerSettingsGui(), this); + Bukkit.getPluginManager().registerEvents(new OtherSettingsGui(), this); + + saveDefaultConfig(); + reloadConfig(); + createRndDropsConfig(); + createBackpackConfig(); + + this.backpack.loadInventoryFromConfig(); + getLogger().info("Plugin loaded!"); + this.sbManager = new ScoreBoardManager(this); + + timer.setTime(getConfig().getInt("timertime")); + + Bukkit.getScheduler().scheduleSyncDelayedTask(this, () -> { + World world = Bukkit.getWorld("world"); + world.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, false); + checkMLGWorld(); + }, 1L); + + if (getConfig().getBoolean("World_Reset")) { + File config = new File(plugin.getDataFolder(), "config.yml"); + config.delete(); + reloadConfig(); + saveConfig(); + this.backpack.clearConfig(); + this.rndDrops.shuffleItems(); + this.rndDrops.saveItems(); + this.rndDrops.loadItems(); + } else { + this.rndDrops.loadItems(); + this.backpack.loadInventoryFromConfig(); + } + + Bukkit.getScheduler().scheduleSyncDelayedTask(this, () -> { + Bukkit.getPluginManager().callEvent(new ServerStatusChangedEvent(true)); + Bukkit.getPluginManager().callEvent(new TimerChangedEvent(timer.isRunning())); + Bukkit.getPluginManager().callEvent(new PlayerCountChangedEvent(Bukkit.getOnlinePlayers().size())); + }, 200L); + } + + @Override + public void onDisable() { + Bukkit.getBanList(BanList.Type.NAME).getBanEntries().forEach(b -> Bukkit.getBanList(BanList.Type.NAME).pardon(b.getTarget())); + if (!getConfig().getBoolean("World_Reset")) { + this.backpack.saveInventoryToConfig();getConfig().set("backpack_size", backpack.getSize() / 9); + } else { + this.backpack.clearConfig(); + } + try { + this.RndDropsConfig.save(this.RndDropsConfigFile); + } catch (IOException e) { + e.printStackTrace(); + } + getConfig().set("timertime", timer.getTime()); + saveConfig(); + getLogger().info("Plugin unloaded"); + } + + public RandomDrops getRandomDropsManager() { + return this.rndDrops; + } + + public FileConfiguration getBackpackConfig() { + return this.BackpackConfig; + } + + private void createBackpackConfig() { + this.backpackConfigFile = new File(getDataFolder(), "backpack.yml"); + if (!this.backpackConfigFile.exists()) { + this.backpackConfigFile.getParentFile().mkdirs(); + saveResource("backpack.yml", false); + } + this.BackpackConfig = new YamlConfiguration(); + try { + this.BackpackConfig.load(this.backpackConfigFile); + } catch (InvalidConfigurationException | IOException e) { + e.printStackTrace(); + } + } + + public FileConfiguration getRndDropsConfig() { + return this.RndDropsConfig; + } + + private void createRndDropsConfig() { + this.RndDropsConfigFile = new File(getDataFolder(), "rnddrops.yml"); + if (!this.RndDropsConfigFile.exists()) { + this.RndDropsConfigFile.getParentFile().mkdirs(); + saveResource("rnddrops.yml", false); + } + this.RndDropsConfig = new YamlConfiguration(); + try { + this.RndDropsConfig.load(this.RndDropsConfigFile); + } catch (IOException | org.bukkit.configuration.InvalidConfigurationException e) { + e.printStackTrace(); + } + } + + public ScoreBoardManager getSBManager() { + return this.sbManager; + } + + public void checkMLGWorld() { + World mlgWorld = Bukkit.getWorld("mlg_challenge"); + if (mlgWorld == null) { + mlgWorld = Bukkit.createWorld((new WorldCreator("mlg_challenge")).type(WorldType.FLAT).generateStructures(false)); + mlgWorld.setAnimalSpawnLimit(0); + mlgWorld.setGameRule(GameRule.DO_MOB_SPAWNING, false); + mlgWorld.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, false); + mlgWorld.setGameRule(GameRule.DO_WEATHER_CYCLE, false); + mlgWorld.setTime(6000L); + } + } + + public ItemStack addGUIItem(Material mat, String name, String... lore) { + ItemStack item = new ItemStack(mat, 1); + ItemMeta meta = item.getItemMeta(); + if (mat != Material.AIR) { + meta.setDisplayName(name); + ArrayList metalore = new ArrayList<>(); + if (lore != null) { + metalore.addAll(Arrays.asList(lore)); + } + meta.setLore(metalore); + item.setItemMeta(meta); + } + return item; + } + + public Player getCurrentEditor() { + return currentEditor; + } + + public void setCurrentEditor(Player currentEditor) { + this.currentEditor = currentEditor; + } + + public boolean hasEditor() { + return currentEditor != null; + } + + public boolean isEditor(Player player) { + return hasEditor() && currentEditor.getUniqueId().equals(player.getUniqueId()); + } + + public Timer getTimer() { + return timer; + } + + public boolean isWaitingForShutdown() { + return waitingForShutdown; + } + + public void setWaitingForShutdown(boolean waitingForShutdown) { + this.waitingForShutdown = waitingForShutdown; + } + + public BackpackGui getBackpack() { + return backpack; + } + + public File getBackpackConfigFile() { + return backpackConfigFile; + } + + public ScoreManager getScoreManager() { + return scoreManager; + } +} diff --git a/src/main/java/de/fanta/challenges/Timer.java b/src/main/java/de/fanta/challenges/Timer.java new file mode 100644 index 0000000..d0d398c --- /dev/null +++ b/src/main/java/de/fanta/challenges/Timer.java @@ -0,0 +1,184 @@ +package de.fanta.challenges; + +import de.fanta.challenges.events.TimerChangedEvent; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.StringUtil; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.Effect; +import org.bukkit.GameMode; +import org.bukkit.GameRule; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.inventory.InventoryType; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; + +import java.util.Random; + +public class Timer { + + private final Challenges plugin; + private final Random random; + private int actionBarTaskId; + private int idleActionBarTaskId; + + private int time; // seconds + private int timeSinceMLG; // seconds + private int maxMLGTime; // seconds + private boolean mlgActive; + private boolean reverse; + + public Timer(Challenges plugin) { + this.plugin = plugin; + this.random = new Random(); + this.maxMLGTime = plugin.getConfig().getInt("mlg.maxtime"); + + if (!isRunning()) { + sendIdleActionBar(); + } + } + + public void startTimer() { + if (idleActionBarTaskId > 0) { + Bukkit.getScheduler().cancelTask(idleActionBarTaskId); + idleActionBarTaskId = -1; + } + actionBarTaskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, () -> { + int random = this.random.nextInt(750); + timeSinceMLG++; + if (random == 638 || timeSinceMLG >= maxMLGTime) { + triggerMLG(); + } + + if (reverse) { + if (time <= 0) { + for (Player p : Bukkit.getOnlinePlayers()) { + p.setGameMode(GameMode.SPECTATOR); + p.sendTitle(ChatColor.DARK_RED + "ZEIT ABGELAUFEN!", ChatColor.RED + "Challenge fehgeschlagen", 10, 60, 10); + } + Bukkit.broadcastMessage(Challenges.PREFIX + ChatColor.DARK_RED + " Die Zeit ist abgelaufen und die Challenge somit fehlgeschlagen!"); + Bukkit.broadcastMessage(Challenges.PREFIX + ChatColor.GREEN + " Seed: " + ChatColor.AQUA + Bukkit.getWorlds().get(0).getSeed()); + + stopTimer(); + } else { + time--; + sendTimerActionBar(ChatColor.AQUA); + } + } else { + time++; + sendTimerActionBar(ChatColor.GREEN); + } + }, 20L, 20L); + + Bukkit.getPluginManager().callEvent(new TimerChangedEvent(true)); + } + + public void stopTimer() { + if (actionBarTaskId > 0) { + Bukkit.getScheduler().cancelTask(actionBarTaskId); + actionBarTaskId = -1; + sendIdleActionBar(); + } + + Bukkit.getPluginManager().callEvent(new TimerChangedEvent(false)); + } + + private void sendIdleActionBar() { + idleActionBarTaskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(plugin, () -> { + for (Player p : Bukkit.getOnlinePlayers()) { + p.sendActionBar(ChatColor.RED + "" + ChatColor.BOLD + "Der Timer ist pausiert."); + if (p.getGameMode() != GameMode.SPECTATOR) { + p.getWorld().playEffect(p.getLocation(), Effect.ENDER_SIGNAL, 2); + } + } + }, 20L, 20L); + } + + public boolean triggerMLG() { + if (plugin.getConfig().getBoolean("mlg.enabled") && !mlgActive && Bukkit.getOnlinePlayers().size() >= 1) { + mlgActive = true; + Bukkit.broadcastMessage(Challenges.PREFIX + " §bZeit für einen MLG! §6Viel Glück!"); + timeSinceMLG = 0; + for (Player p : Bukkit.getOnlinePlayers()) { + if (p.getGameMode() == GameMode.SURVIVAL && !p.isDead()) { + tpMLG(p); + } + } + return true; + } + return false; + } + + private void sendTimerActionBar(ChatColor color) { + for (Player p : Bukkit.getOnlinePlayers()) { + p.sendActionBar(formatTime(color)); + } + } + + public String formatTime(ChatColor color) { + return color + StringUtil.formatTimespan((long) time * 1000L, " Tag/e ", "", "", "", ":", ":", false, true); + } + + public void reverseTimer() { + this.reverse = !this.reverse; + } + + public void tpMLG(Player p) { + p.closeInventory(); + Inventory inv = Bukkit.createInventory(p, InventoryType.PLAYER, p.getName()); + inv.setContents(p.getInventory().getContents()); + p.getInventory().clear(); + p.getInventory().setItemInMainHand(new ItemStack(Material.WATER_BUCKET)); + int rndY = random.nextInt(20); + Location oldloc = p.getLocation(); + + Location newloc = new Location(Bukkit.getWorld("mlg_challenge"), p.getLocation().getBlockX(), (50 + rndY), p.getLocation().getBlockZ()); + p.teleport(newloc); + mlgResult(p, oldloc, inv); + } + + public void mlgResult(final Player p, final Location loc, final Inventory inv) { + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> { + mlgActive = false; + if (!p.isDead() && p.getWorld() == Bukkit.getWorld("mlg_challenge")) { + ChatUtil.sendNormalMessage(p, "§aDu hast den §bMLG §aerfolgreich absolviert! §6Weitere folgen..."); + p.setInvulnerable(true); + mlgBack(p, loc, inv); + } else if (Bukkit.getWorlds().get(0).getGameRuleValue(GameRule.KEEP_INVENTORY)) { + p.getInventory().setContents(inv.getContents()); + } + }, 100L); + } + + public void mlgBack(final Player p, Location loc, Inventory inv) { + p.teleport(loc); + p.getInventory().setContents(inv.getContents()); + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> p.setInvulnerable(false), 60L); + } + + public boolean isMlgActive() { + return mlgActive; + } + + public void setMlgActive(boolean mlgActive) { + this.mlgActive = mlgActive; + } + + public boolean isRunning() { + return actionBarTaskId > 0; + } + + public boolean isReverse() { + return reverse; + } + + public int getTime() { + return time; + } + + public void setTime(int seconds) { + this.time = seconds; + } +} \ No newline at end of file diff --git a/src/main/java/de/fanta/challenges/challenges/RandomDrops.java b/src/main/java/de/fanta/challenges/challenges/RandomDrops.java new file mode 100644 index 0000000..0293e67 --- /dev/null +++ b/src/main/java/de/fanta/challenges/challenges/RandomDrops.java @@ -0,0 +1,60 @@ +package de.fanta.challenges.challenges; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.Random; +import java.util.stream.Collectors; + +import de.fanta.challenges.Challenges; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.configuration.file.FileConfiguration; + +public class RandomDrops { + private final ArrayList BLOCKS; + + private final ArrayList ITEM_DROPS; + + private HashMap drops = new HashMap<>(); + + public RandomDrops() { + this.BLOCKS = (ArrayList) Arrays. stream(Material.values()).filter(mat -> mat.isBlock()).collect(Collectors.toList()); + this.ITEM_DROPS = (ArrayList) Arrays. stream(Material.values()).filter(mat -> (mat.isItem() || mat == Material.BEDROCK)).collect(Collectors.toList()); + } + + public void shuffleItems() { + Collections.shuffle(this.ITEM_DROPS); + ArrayList itemDropsCopy = new ArrayList<>(); + this.ITEM_DROPS.forEach(m -> itemDropsCopy.add(m)); + this.BLOCKS.forEach(mat -> { + int r = (new Random()).nextInt(itemDropsCopy.size() - 1); + this.drops.put(mat, itemDropsCopy.get(r)); + itemDropsCopy.remove(r); + }); + saveItems(); + } + + public void saveItems() { + FileConfiguration config = Challenges.getPlugin().getRndDropsConfig(); + config.set("drops", this.drops.entrySet().stream().map(entry -> (new StringBuilder()).append(entry.getKey()).append(":").append(entry.getValue()).toString()).collect(Collectors.toList())); + } + + public void loadItems() { + this.drops.clear(); + FileConfiguration config = Challenges.getPlugin().getRndDropsConfig(); + if (config.isList("drops")) { + config.getStringList("drops").forEach(str -> { + String[] materialSplitted = str.split(":"); + this.drops.put(Material.getMaterial(materialSplitted[0]), Material.getMaterial(materialSplitted[1])); + }); + } else { + shuffleItems(); + } + } + + public Material getMaterialFromBlock(Block block) { + return this.drops.get(block.getType()); + } +} diff --git a/src/main/java/de/fanta/challenges/commands/BackpackCommand.java b/src/main/java/de/fanta/challenges/commands/BackpackCommand.java new file mode 100644 index 0000000..1460de3 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/BackpackCommand.java @@ -0,0 +1,28 @@ +package de.fanta.challenges.commands; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class BackpackCommand extends SubCommand { + private final Challenges plugin; + + public BackpackCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + Player p = (Player) sender; + plugin.getBackpack().open(p); + return true; + } +} diff --git a/src/main/java/de/fanta/challenges/commands/CommandRegistration.java b/src/main/java/de/fanta/challenges/commands/CommandRegistration.java new file mode 100644 index 0000000..e3b1105 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/CommandRegistration.java @@ -0,0 +1,94 @@ +package de.fanta.challenges.commands; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.commands.challenges.ChallengesCommand; +import de.fanta.challenges.commands.challenges.ChallengesHelpCommand; +import de.fanta.challenges.commands.challenges.ChallengesKickCommand; +import de.fanta.challenges.commands.coords.CoordsCommand; +import de.fanta.challenges.commands.coords.CoordsDeleteCommand; +import de.fanta.challenges.commands.coords.CoordsGetCommand; +import de.fanta.challenges.commands.coords.CoordsSaveCommand; +import de.fanta.challenges.commands.coords.CoordsShareCommand; +import de.fanta.challenges.commands.editor.EditorCommand; +import de.fanta.challenges.commands.editor.EditorSetCommand; +import de.fanta.challenges.commands.event.EventCommand; +import de.fanta.challenges.commands.event.EventToggleCommand; +import de.fanta.challenges.commands.hp.HPAddCommand; +import de.fanta.challenges.commands.hp.HPGetCommand; +import de.fanta.challenges.commands.hp.HPMaxCommand; +import de.fanta.challenges.commands.hp.HPRemoveCommand; +import de.fanta.challenges.commands.hp.HPSetCommand; +import de.fanta.challenges.commands.reset.ResetCommand; +import de.fanta.challenges.commands.reset.ResetConfirmCommand; +import de.fanta.challenges.commands.revive.ReviveCommandTODO; +import de.fanta.challenges.commands.settings.SettingsCommandTODO; +import de.fanta.challenges.commands.timer.TimerCommand; +import de.fanta.challenges.commands.timer.TimerPauseCommand; +import de.fanta.challenges.commands.timer.TimerResetCommand; +import de.fanta.challenges.commands.timer.TimerReverseCommand; +import de.fanta.challenges.commands.timer.TimerSetCommand; +import de.fanta.challenges.commands.timer.TimerStartCommand; +import de.iani.cubesideutils.bukkit.commands.CommandRouter; + +public class CommandRegistration { + private final Challenges plugin; + + public CommandRegistration(Challenges plugin) { + this.plugin = plugin; + } + + public void registerCommands() { + plugin.getCommand("settings").setExecutor(new SettingsCommandTODO(plugin)); + plugin.getCommand("revive").setExecutor(new ReviveCommandTODO(plugin)); + + CommandRouter challengesRouter = new CommandRouter(plugin.getCommand("challenges")); + challengesRouter.addCommandMapping(new ChallengesCommand(plugin)); + challengesRouter.addCommandMapping(new ChallengesHelpCommand(plugin), "help"); + challengesRouter.addCommandMapping(new ChallengesKickCommand(plugin), "kick"); + + + CommandRouter resetRouter = new CommandRouter(plugin.getCommand("reset")); + resetRouter.addCommandMapping(new ResetCommand(plugin)); + resetRouter.addCommandMapping(new ResetConfirmCommand(plugin), "confirm"); + + CommandRouter backpackRouter = new CommandRouter(plugin.getCommand("backpack")); + backpackRouter.addCommandMapping(new BackpackCommand(plugin)); + + CommandRouter coordsRouter = new CommandRouter(plugin.getCommand("coords")); + coordsRouter.addCommandMapping(new CoordsCommand(plugin)); + coordsRouter.addCommandMapping(new CoordsShareCommand(plugin), "share"); + coordsRouter.addCommandMapping(new CoordsGetCommand(plugin), "get"); + coordsRouter.addCommandMapping(new CoordsSaveCommand(plugin), "save"); + coordsRouter.addCommandMapping(new CoordsDeleteCommand(plugin), "delete"); + + CommandRouter hpRouter = new CommandRouter(plugin.getCommand("hp")); + hpRouter.addCommandMapping(new HPAddCommand(plugin), "add"); + hpRouter.addCommandMapping(new HPGetCommand(plugin), "get"); + hpRouter.addCommandMapping(new HPMaxCommand(plugin), "max"); + hpRouter.addCommandMapping(new HPRemoveCommand(plugin), "remove"); + hpRouter.addCommandMapping(new HPSetCommand(plugin), "set"); + + CommandRouter timerRouter = new CommandRouter(plugin.getCommand("timer")); + timerRouter.addCommandMapping(new TimerCommand(plugin)); + timerRouter.addCommandMapping(new TimerPauseCommand(plugin), "pause"); + timerRouter.addCommandMapping(new TimerResetCommand(plugin), "reset"); + timerRouter.addCommandMapping(new TimerReverseCommand(plugin), "reverse"); + timerRouter.addCommandMapping(new TimerSetCommand(plugin), "set"); + timerRouter.addCommandMapping(new TimerStartCommand(plugin), "start"); + + CommandRouter forcemlgRouter = new CommandRouter(plugin.getCommand("forcemlg")); + forcemlgRouter.addCommandMapping(new ForceMLGCommand(plugin)); + + CommandRouter editorRouter = new CommandRouter(plugin.getCommand("editor")); + editorRouter.addCommandMapping(new EditorCommand(plugin)); + editorRouter.addCommandMapping(new EditorSetCommand(plugin), "set"); + + CommandRouter leaveRouter = new CommandRouter(plugin.getCommand("leave")); + leaveRouter.addCommandMapping(new LeaveCommand()); + + CommandRouter eventRouter = new CommandRouter(plugin.getCommand("event")); + eventRouter.addCommandMapping(new EventCommand(plugin)); + eventRouter.addCommandMapping(new EventToggleCommand(plugin, true), "enable"); + eventRouter.addCommandMapping(new EventToggleCommand(plugin, false), "disable"); + } +} diff --git a/src/main/java/de/fanta/challenges/commands/ForceMLGCommand.java b/src/main/java/de/fanta/challenges/commands/ForceMLGCommand.java new file mode 100644 index 0000000..dfd7d21 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/ForceMLGCommand.java @@ -0,0 +1,40 @@ +package de.fanta.challenges.commands; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class ForceMLGCommand extends SubCommand { + + private final Challenges plugin; + + public ForceMLGCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + if (!plugin.getTimer().triggerMLG()) { + ChatUtil.sendWarningMessage(sender, "Ein MLG findet bereits statt! Oder MLGs sind nicht aktiv."); + } + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return true; + } + +} diff --git a/src/main/java/de/fanta/challenges/commands/LeaveCommand.java b/src/main/java/de/fanta/challenges/commands/LeaveCommand.java new file mode 100644 index 0000000..2f1e9d6 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/LeaveCommand.java @@ -0,0 +1,27 @@ +package de.fanta.challenges.commands; + +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class LeaveCommand extends SubCommand { + + public LeaveCommand() { + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } else { + ((Player) sender).performCommand("tt challenge"); + } + return true; + } + +} + diff --git a/src/main/java/de/fanta/challenges/commands/challenges/ChallengesCommand.java b/src/main/java/de/fanta/challenges/commands/challenges/ChallengesCommand.java new file mode 100644 index 0000000..51de8bf --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/challenges/ChallengesCommand.java @@ -0,0 +1,24 @@ +package de.fanta.challenges.commands.challenges; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; + +public class ChallengesCommand extends SubCommand { + + private final Challenges plugin; + + public ChallengesCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + ChatUtil.sendNormalMessage(sender, "Challenges v" + plugin.getDescription().getVersion() + " by " + plugin.getDescription().getAuthors()); + ChatUtil.sendNormalMessage(sender, "Nutze /challenges help für Hilfe"); + return true; + } +} diff --git a/src/main/java/de/fanta/challenges/commands/challenges/ChallengesHelpCommand.java b/src/main/java/de/fanta/challenges/commands/challenges/ChallengesHelpCommand.java new file mode 100644 index 0000000..0774076 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/challenges/ChallengesHelpCommand.java @@ -0,0 +1,47 @@ +package de.fanta.challenges.commands.challenges; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class ChallengesHelpCommand extends SubCommand { + + private final Challenges plugin; + + public ChallengesHelpCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + ChatUtil.sendNormalMessage(sender, "Verfügbare Befehle:"); + ChatUtil.sendNormalMessage(sender, "/HP - Verwalte die HP einzelner Spieler"); + ChatUtil.sendNormalMessage(sender, "/Coords - Teile oder speichere Coordinaten"); + ChatUtil.sendNormalMessage(sender, "/Settings - Verwalte die Challenges Einstellungen"); + ChatUtil.sendNormalMessage(sender, "/Timer - Verwalte den Timer"); + ChatUtil.sendNormalMessage(sender, "/Revive - Wiederbelebe Spieler"); + ChatUtil.sendNormalMessage(sender, "/Backpack | /bp - öffne das Backpack"); + ChatUtil.sendNormalMessage(sender, "/Reset - Generiert eine neue Welt, setzt den Timer zurück und löscht gespeicherte Positionen"); + ChatUtil.sendNormalMessage(sender, "/forcemlg - Triggert einen MLG wenn MLG aktiv ist"); + ChatUtil.sendNormalMessage(sender, "/editor - zeigt dir den aktuellen Editor an"); + return true; + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP Kaufen!"); + return true; + } + } +} diff --git a/src/main/java/de/fanta/challenges/commands/challenges/ChallengesKickCommand.java b/src/main/java/de/fanta/challenges/commands/challenges/ChallengesKickCommand.java new file mode 100644 index 0000000..e0043df --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/challenges/ChallengesKickCommand.java @@ -0,0 +1,61 @@ +package de.fanta.challenges.commands.challenges; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.BanList; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class ChallengesKickCommand extends SubCommand { + private final Challenges plugin; + + public ChallengesKickCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + if (args.hasNext()) { + String playerName = args.getNext(); + Player player = Bukkit.getPlayer(playerName); + + if (player == sender) { + ChatUtil.sendErrorMessage(sender,"Du kannst dich nicht selbst kicken"); + return true; + } + + if (player == null) { + ChatUtil.sendErrorMessage(sender, "Dieser Spieler ist nicht online!"); + } else { + player.performCommand("tt challenge"); + ChatUtil.sendWarningMessage(player, "Du wurdest vom Editor gekickt!"); + ChatUtil.sendWarningMessage(player, "Du kannst in einer Minute wieder joinen"); + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> { + player.banPlayer("Du wurdest vom Editor gekickt"); + }, 5L); + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> { + Bukkit.getBanList(BanList.Type.NAME).pardon(player.getName()); + }, 20 * 60); + } + return true; + } + return false; + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! Nur " + plugin.getCurrentEditor().getName() + " kann Spieler kicken"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + } +} diff --git a/src/main/java/de/fanta/challenges/commands/coords/CoordsCommand.java b/src/main/java/de/fanta/challenges/commands/coords/CoordsCommand.java new file mode 100644 index 0000000..705fc8d --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/coords/CoordsCommand.java @@ -0,0 +1,71 @@ +package de.fanta.challenges.commands.coords; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; + +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; + +public class CoordsCommand extends SubCommand { + + private Challenges plugin = Challenges.getPlugin(); + + public static final Inventory CoordsGUI = Bukkit.createInventory(null, 45, "§6Koordinaten"); + + public static final String CGUIN = "§6Koordinaten"; + + public CoordsCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + createMainGUI((Player) sender); + + return true; +} + + public void createMainGUI(Player p) { + int i = 0; + String w; + String x; + String y; + String z; + for (String key : plugin.getConfig().getConfigurationSection("Saved_Locations").getKeys(false)) { + if (i >= 45) { + break; + } + w = plugin.getConfig().getString("Saved_Locations." + key + ".World"); + x = plugin.getConfig().getString("Saved_Locations." + key + ".BlockX"); + y = plugin.getConfig().getString("Saved_Locations." + key + ".BlockY"); + z = plugin.getConfig().getString("Saved_Locations." + key + ".BlockZ"); + CoordsGUI.setItem(i, plugin.addGUIItem(getBlock(w), key, "§bX: §c" + x, "§bY: §c" + y, "§bZ: §c" + z)); + i++; + } + for (int ii = i; ii < 45; ii++) { + CoordsGUI.setItem(ii, plugin.addGUIItem(Material.AIR, "")); + } + p.openInventory(CoordsGUI); + } + + private Material getBlock(String wname) { + ItemStack mat = new ItemStack(Material.GRASS_BLOCK); + if (wname.equals(Bukkit.getWorlds().get(1).getName())) { + mat.setType(Material.NETHERRACK); + } else if (wname.equals(Bukkit.getWorlds().get(2).getName())) { + mat.setType(Material.END_STONE); + } + return mat.getType(); + } +} \ No newline at end of file diff --git a/src/main/java/de/fanta/challenges/commands/coords/CoordsDeleteCommand.java b/src/main/java/de/fanta/challenges/commands/coords/CoordsDeleteCommand.java new file mode 100644 index 0000000..e8709e0 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/coords/CoordsDeleteCommand.java @@ -0,0 +1,63 @@ +package de.fanta.challenges.commands.coords; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; +import org.bukkit.inventory.Inventory; + +import java.util.Collection; + +public class CoordsDeleteCommand extends SubCommand { + + public static final Inventory CoordsDeleteGUI = Bukkit.createInventory(null, 9, "§6Entferne Koordinate"); + public static final String CDGUIN = "§6Entferne Koordinate"; + private final Challenges plugin; + + public CoordsDeleteCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + Player player = (Player) sender; + + if (args.hasNext()) { + String next = args.getNext(); + if (plugin.getConfig().contains("Saved_Locations." + next)) { + createDeleteGUI(player, next); + player.openInventory(CoordsDeleteGUI); + } else { + ChatUtil.sendWarningMessage(player, "Diese Position existiert nicht!"); + } + return true; + } + return false; + } + + public void createDeleteGUI(Player p, String dname) { + CoordsDeleteGUI.setItem(0, plugin.addGUIItem(Material.LIME_TERRACOTTA, "§aLöschen bestätigen", "§bWegpunkt: §c" + dname)); + CoordsDeleteGUI.setItem(4, plugin.addGUIItem(Material.ORANGE_BANNER, dname)); + for (int i = 1; i < 8; i++) { + if (CoordsDeleteGUI.getItem(i) == null) { + CoordsDeleteGUI.setItem(i, plugin.addGUIItem(Material.ORANGE_STAINED_GLASS_PANE, "")); + } + } + CoordsDeleteGUI.setItem(8, plugin.addGUIItem(Material.RED_TERRACOTTA, "§cLöschen abbrechen", "§bWegpunkt: §c" + dname)); + p.openInventory(CoordsDeleteGUI); + } + + @Override + public Collection onTabComplete(CommandSender sender, Command command, String alias, ArgsParser args) { + return plugin.getConfig().getConfigurationSection("Saved_Locations").getKeys(false); + } +} diff --git a/src/main/java/de/fanta/challenges/commands/coords/CoordsGetCommand.java b/src/main/java/de/fanta/challenges/commands/coords/CoordsGetCommand.java new file mode 100644 index 0000000..15991d8 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/coords/CoordsGetCommand.java @@ -0,0 +1,53 @@ +package de.fanta.challenges.commands.coords; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +import java.util.Collection; + +public class CoordsGetCommand extends SubCommand { + + private final Challenges plugin; + + public CoordsGetCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + Player player = (Player) sender; + + if (!args.hasNext()) { + ChatUtil.sendNormalMessage(player, "Verfügbare Positionen:"); + for (String key : plugin.getConfig().getConfigurationSection("Saved_Locations").getKeys(false)) { + ChatUtil.sendNormalMessage(player, key); + } + } else { + String next = args.getNext(); + if (plugin.getConfig().contains("Saved_Locations." + next)) { + String w = plugin.getConfig().getString("Saved_Locations." + next + ".World"); + String x = plugin.getConfig().getString("Saved_Locations." + next + ".BlockX"); + String y = plugin.getConfig().getString("Saved_Locations." + next + ".BlockY"); + String z = plugin.getConfig().getString("Saved_Locations." + next + ".BlockZ"); + ChatUtil.sendNormalMessage(player, ChatUtil.NORMAL + "Position " + ChatUtil.WARNING + next + ChatUtil.NORMAL + ": " + ChatUtil.WARNING + "[" + x + "/" + y + "/" + z + " " + w + "]"); + } else { + ChatUtil.sendWarningMessage(player, "§cDiese Position existiert nicht!"); + } + } + return true; + } + + @Override + public Collection onTabComplete(CommandSender sender, Command command, String alias, ArgsParser args) { + return plugin.getConfig().getConfigurationSection("Saved_Locations").getKeys(false); + } +} diff --git a/src/main/java/de/fanta/challenges/commands/coords/CoordsSaveCommand.java b/src/main/java/de/fanta/challenges/commands/coords/CoordsSaveCommand.java new file mode 100644 index 0000000..5d8bbc4 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/coords/CoordsSaveCommand.java @@ -0,0 +1,49 @@ +package de.fanta.challenges.commands.coords; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class CoordsSaveCommand extends SubCommand { + + private final Challenges plugin; + + public CoordsSaveCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + Player player = (Player) sender; + + if (args.hasNext()) { + String next = args.getNext(); + if (!plugin.getConfig().contains("Saved_Locations." + next)) { + String w = player.getLocation().getWorld().getName().toLowerCase(); + int x = player.getLocation().getBlockX(); + int y = player.getLocation().getBlockY(); + int z = player.getLocation().getBlockZ(); + ChatUtil.sendNormalMessage(player, ChatUtil.NORMAL + "Position " + ChatUtil.WARNING + next + ChatUtil.NORMAL + ": " + ChatUtil.WARNING + "[" + x + "/" + y + "/" + z + " " + w + "]"); + plugin.getConfig().set("Saved_Locations." + next + ".World", w); + plugin.getConfig().set("Saved_Locations." + next + ".BlockX", x); + plugin.getConfig().set("Saved_Locations." + next + ".BlockY", y); + plugin.getConfig().set("Saved_Locations." + next + ".BlockZ", z); + plugin.saveConfig(); + } else { + ChatUtil.sendWarningMessage(player, "Diese Position existiert bereits! Benutze einen anderen Namen oder lösche die alte zuerst mit /coords delete " + next); + } + return true; + } + return false; + } + + +} diff --git a/src/main/java/de/fanta/challenges/commands/coords/CoordsShareCommand.java b/src/main/java/de/fanta/challenges/commands/coords/CoordsShareCommand.java new file mode 100644 index 0000000..59e132b --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/coords/CoordsShareCommand.java @@ -0,0 +1,34 @@ +package de.fanta.challenges.commands.coords; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class CoordsShareCommand extends SubCommand { + + private final Challenges plugin; + + public CoordsShareCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + Player player = (Player) sender; + String w = player.getLocation().getWorld().getName().toLowerCase(); + int x = player.getLocation().getBlockX(); + int y = player.getLocation().getBlockY(); + int z = player.getLocation().getBlockZ(); + Bukkit.broadcastMessage(Challenges.PREFIX + " " + ChatUtil.PLAYER + sender.getName() + ChatUtil.NORMAL + " ist bei " + ChatUtil.WARNING + x + "/" + y + "/" + z + " " + ChatUtil.WARNING + w); + return true; + } +} diff --git a/src/main/java/de/fanta/challenges/commands/editor/EditorCommand.java b/src/main/java/de/fanta/challenges/commands/editor/EditorCommand.java new file mode 100644 index 0000000..66b4677 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/editor/EditorCommand.java @@ -0,0 +1,35 @@ +package de.fanta.challenges.commands.editor; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class EditorCommand extends SubCommand { + + private final Challenges plugin; + + public EditorCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + if (plugin.getCurrentEditor() != null) { + ChatUtil.sendNormalMessage(sender, plugin.getCurrentEditor().getName() + " ist der aktuelle Editor"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + } + +} diff --git a/src/main/java/de/fanta/challenges/commands/editor/EditorSetCommand.java b/src/main/java/de/fanta/challenges/commands/editor/EditorSetCommand.java new file mode 100644 index 0000000..1cfc619 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/editor/EditorSetCommand.java @@ -0,0 +1,56 @@ +package de.fanta.challenges.commands.editor; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class EditorSetCommand extends SubCommand { + + private final Challenges plugin; + + public EditorSetCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + if (args.hasNext()) { + String playerName = args.getNext(); + Player player = Bukkit.getPlayer(playerName); + + if (player == null) { + ChatUtil.sendErrorMessage(sender, "Dieser Spieler ist nicht online!"); + return true; + } else if (!plugin.isEditor(player)){ + plugin.setCurrentEditor(player); + Bukkit.broadcastMessage(Challenges.PREFIX + " " + ChatColor.GREEN + player.getName() + " wurde von " + sender.getName() + " zum Editor ernannt"); + ChatUtil.sendNormalMessage(player, "Du bist jetzt Editor und kannst diese Lobby bearbeiten. (/challenges)"); + return true; + } else { + ChatUtil.sendWarningMessage(sender, "Du bist bereits Editor!"); + return true; + } + } + return true; + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! Nur " + plugin.getCurrentEditor().getName() + " kann einen neuen Editor bestimmen!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + } + +} diff --git a/src/main/java/de/fanta/challenges/commands/event/EventCommand.java b/src/main/java/de/fanta/challenges/commands/event/EventCommand.java new file mode 100644 index 0000000..724fcf6 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/event/EventCommand.java @@ -0,0 +1,34 @@ +package de.fanta.challenges.commands.event; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class EventCommand extends SubCommand { + private final Challenges plugin; + + public EventCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + if (sender.hasPermission("challenges.event")) { + ChatUtil.sendNormalMessage(sender, "--- Event Commands ---"); + ChatUtil.sendNormalMessage(sender, "/event enable - aktiviert die Event-Funktion"); + ChatUtil.sendNormalMessage(sender, "/event disable - deaktiviert die Event-Funktion"); + ChatUtil.sendNormalMessage(sender, "/event settings - öffnet die Event-Einstellungen"); + ChatUtil.sendNormalMessage(sender, "--- ************** ---"); + return true; + } + return false; + } +} diff --git a/src/main/java/de/fanta/challenges/commands/event/EventToggleCommand.java b/src/main/java/de/fanta/challenges/commands/event/EventToggleCommand.java new file mode 100644 index 0000000..9aea66c --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/event/EventToggleCommand.java @@ -0,0 +1,45 @@ +package de.fanta.challenges.commands.event; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.fanta.challenges.utils.guiutils.GUIUtils; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class EventToggleCommand extends SubCommand { + + private final Challenges plugin; + private final boolean enable; + + public EventToggleCommand(Challenges plugin, boolean enable) { + this.plugin = plugin; + this.enable = enable; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!sender.hasPermission("challenges.event")) { + ChatUtil.sendErrorMessage(sender, "Keine Berechtigung"); + return true; + } + if (enable) { + if (!plugin.getConfig().getBoolean("event")) { + GUIUtils.setConfig("event", true); + GUIUtils.sendTitleToAll("Event", "Event-Modus aktiviert", ChatColor.GREEN); + } else { + ChatUtil.sendErrorMessage(sender, "Das Event läuft bereits!"); + return true; + } + } else { + GUIUtils.setConfig("event", false); + GUIUtils.sendTitleToAll("Event", "Event-Modus deaktiviert", ChatColor.RED); + } + plugin.getSBManager().updateEventScoreboard(); + return true; + } +} diff --git a/src/main/java/de/fanta/challenges/commands/hp/HPAddCommand.java b/src/main/java/de/fanta/challenges/commands/hp/HPAddCommand.java new file mode 100644 index 0000000..e49c1a1 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/hp/HPAddCommand.java @@ -0,0 +1,67 @@ +package de.fanta.challenges.commands.hp; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.Bukkit; +import org.bukkit.attribute.Attribute; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class HPAddCommand extends SubCommand { + + private final Challenges plugin; + + public HPAddCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + if (args.hasNext()) { + String playerName = args.getNext(); + Player player = Bukkit.getPlayer(playerName); + + if (player == null) { + ChatUtil.sendErrorMessage(sender, "Dieser Spieler ist nicht online!"); + return true; + } + + if (args.hasNext()) { + double input = args.getNext(0.0); + double finalAddHP = player.getHealth() + input; + + if (finalAddHP <= player.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue() && finalAddHP >= 0) { + player.setHealth(finalAddHP); + ChatUtil.sendNormalMessage(player, "Du wurdest von " + sender.getName() + " um " + input + "HP geheilt!"); + ChatUtil.sendNormalMessage(sender, "Du hast " + player.getName() + " " + input + "HP hinzugefügt!"); + } else { + ChatUtil.sendErrorMessage(sender, "Operation nicht möglich!"); + } + return true; + } + } + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return false; + } + + @Override + public boolean requiresPlayer() { + return true; + } + + @Override + public String getUsage() { + return " - Füge einem Spieler die angegebene Zahl an Herzen hinzu"; + } +} diff --git a/src/main/java/de/fanta/challenges/commands/hp/HPGetCommand.java b/src/main/java/de/fanta/challenges/commands/hp/HPGetCommand.java new file mode 100644 index 0000000..ea83474 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/hp/HPGetCommand.java @@ -0,0 +1,54 @@ +package de.fanta.challenges.commands.hp; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class HPGetCommand extends SubCommand { + + private final Challenges plugin; + + public HPGetCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + if (args.hasNext()) { + String playerName = args.getNext(); + Player player = Bukkit.getPlayer(playerName); + + if (player != null) { + ChatUtil.sendNormalMessage(sender, player.getName() + " besitzt derzeit " + player.getHealth() + "HP!"); + } else { + ChatUtil.sendErrorMessage(sender, "Dieser Spieler ist nicht online!"); + } + return true; + } + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return false; + } + + @Override + public boolean requiresPlayer() { + return true; + } + + @Override + public String getUsage() { + return " - Erhalte die aktuellen HP eines Spielers"; + } +} diff --git a/src/main/java/de/fanta/challenges/commands/hp/HPMaxCommand.java b/src/main/java/de/fanta/challenges/commands/hp/HPMaxCommand.java new file mode 100644 index 0000000..9c3345a --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/hp/HPMaxCommand.java @@ -0,0 +1,55 @@ +package de.fanta.challenges.commands.hp; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.Bukkit; +import org.bukkit.attribute.Attribute; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class HPMaxCommand extends SubCommand { + + private final Challenges plugin; + + public HPMaxCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + if (args.hasNext()) { + double next = args.getNext(-1.0); + if (next > 0) { + for (Player pp : Bukkit.getOnlinePlayers()) { + pp.getAttribute(Attribute.GENERIC_MAX_HEALTH).setBaseValue(next); + pp.setHealth(pp.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue()); + } + ChatUtil.sendNormalMessage(sender, "Du hast die maximalen HP auf " + next + " gesetzt!"); + return true; + } + } + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return false; + } + + @Override + public boolean requiresPlayer() { + return true; + } + + @Override + public String getUsage() { + return " - Setze die maximalen HP aller Spieler"; + } +} \ No newline at end of file diff --git a/src/main/java/de/fanta/challenges/commands/hp/HPRemoveCommand.java b/src/main/java/de/fanta/challenges/commands/hp/HPRemoveCommand.java new file mode 100644 index 0000000..e86b78a --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/hp/HPRemoveCommand.java @@ -0,0 +1,66 @@ +package de.fanta.challenges.commands.hp; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.Bukkit; +import org.bukkit.attribute.Attribute; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class HPRemoveCommand extends SubCommand { + + private final Challenges plugin; + + public HPRemoveCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + if (args.hasNext()) { + String playerName = args.getNext(); + Player player = Bukkit.getPlayer(playerName); + + if (player == null) { + ChatUtil.sendErrorMessage(sender, "Dieser Spieler ist nicht online!"); + return true; + } + + if (args.hasNext()) { + double input = args.getNext(0.0); + double finalRemoveHP = player.getHealth() - input; + if (finalRemoveHP <= player.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue() && finalRemoveHP >= 0) { + player.setHealth(finalRemoveHP); + ChatUtil.sendNormalMessage(player, sender.getName() + " hat dir " + input + " HP entfernt!"); + ChatUtil.sendNormalMessage(sender, "Du hast " + player.getName() + " " + input + " HP entfernt!"); + } else { + ChatUtil.sendErrorMessage(sender, "Operation nicht möglich!"); + } + return true; + } + } + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return false; + } + + @Override + public boolean requiresPlayer() { + return true; + } + + @Override + public String getUsage() { + return " - Entferne einem Spieler die angegebene Zahl an Herzen"; + } +} diff --git a/src/main/java/de/fanta/challenges/commands/hp/HPSetCommand.java b/src/main/java/de/fanta/challenges/commands/hp/HPSetCommand.java new file mode 100644 index 0000000..0bc071b --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/hp/HPSetCommand.java @@ -0,0 +1,65 @@ +package de.fanta.challenges.commands.hp; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.Bukkit; +import org.bukkit.attribute.Attribute; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class HPSetCommand extends SubCommand { + + private final Challenges plugin; + + public HPSetCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + if (args.hasNext()) { + String playerName = args.getNext(); + Player player = Bukkit.getPlayer(playerName); + + if (player == null) { + ChatUtil.sendErrorMessage(sender, "Dieser Spieler ist nicht online!"); + return true; + } + + if (args.hasNext()) { + double input = args.getNext(0.0); + if (input <= player.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue() && input >= 0) { + player.setHealth(input); + ChatUtil.sendNormalMessage(player, sender.getName() + " hat deine HP auf " + input + " gesetzt!"); + ChatUtil.sendNormalMessage(sender, "Du hast die HP von " + player.getName() + " auf " + input + " gesetzt!"); + } else { + ChatUtil.sendErrorMessage(sender, "Operation nicht möglich!"); + } + return true; + } + } + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return false; + } + + @Override + public boolean requiresPlayer() { + return true; + } + + @Override + public String getUsage() { + return " - Setze die Herzen eines Spieler auf die angegebene Zahl"; + } +} \ No newline at end of file diff --git a/src/main/java/de/fanta/challenges/commands/reset/ResetCommand.java b/src/main/java/de/fanta/challenges/commands/reset/ResetCommand.java new file mode 100644 index 0000000..8fa6d69 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/reset/ResetCommand.java @@ -0,0 +1,38 @@ +package de.fanta.challenges.commands.reset; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.guis.ResetGui; +import de.fanta.challenges.utils.ChatUtil; +import de.fanta.challenges.commands.BackpackCommand; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class ResetCommand extends SubCommand { + + private final Challenges plugin; + + public ResetCommand(Challenges plugin) { + this.plugin = plugin; + } + BackpackCommand backpack; + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + ResetGui.createResetGUI((Player) sender); + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! Nur" + plugin.getCurrentEditor().getName() + " kann die Map zurücksetzen!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return true; + } +} + + diff --git a/src/main/java/de/fanta/challenges/commands/reset/ResetConfirmCommand.java b/src/main/java/de/fanta/challenges/commands/reset/ResetConfirmCommand.java new file mode 100644 index 0000000..4e66e22 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/reset/ResetConfirmCommand.java @@ -0,0 +1,52 @@ +package de.fanta.challenges.commands.reset; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.commands.BackpackCommand; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class ResetConfirmCommand extends SubCommand { + + private final Challenges plugin; + + public ResetConfirmCommand(Challenges plugin) { + this.plugin = plugin; + } + BackpackCommand backpack; + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if ((sender instanceof Player && plugin.isEditor((Player) sender)) || sender.hasPermission("Challenges.editor.override")) { + plugin.getTimer().stopTimer(); + plugin.getTimer().setTime(0); + for (Player p : Bukkit.getOnlinePlayers()) { + p.sendTitle(ChatColor.of("#0ddead") + "Server wird zurückgesetzt!", ChatColor.RED + "Bitte warte einen Moment" + ChatColor.of("#0ddead") + "." + ChatColor.AQUA + "." + ChatColor.YELLOW + ".", 10, 220, 10); + p.performCommand("tt challenge"); + } + plugin.getConfig().set("World_Name", Bukkit.getWorlds().get(0).getName()); + plugin.getConfig().set("World_Reset", true); + for (String key : plugin.getConfig().getConfigurationSection("Saved_Locations").getKeys(false)) { + plugin.getConfig().set("Saved_Locations." + key, null); + } + plugin.saveConfig(); + + plugin.setWaitingForShutdown(true); + + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, Bukkit::shutdown, 60); + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! Nur" + plugin.getCurrentEditor().getName() + " kann die Map zurücksetzen!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return true; + } +} diff --git a/src/main/java/de/fanta/challenges/commands/revive/ReviveCommandTODO.java b/src/main/java/de/fanta/challenges/commands/revive/ReviveCommandTODO.java new file mode 100644 index 0000000..5a8af9a --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/revive/ReviveCommandTODO.java @@ -0,0 +1,81 @@ +package de.fanta.challenges.commands.revive; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import org.bukkit.Bukkit; +import org.bukkit.GameMode; +import org.bukkit.Location; +import org.bukkit.OfflinePlayer; +import org.bukkit.World; +import org.bukkit.attribute.Attribute; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class ReviveCommandTODO implements CommandExecutor { + + private final Challenges plugin; + + public ReviveCommandTODO(Challenges plugin) { + this.plugin = plugin; + } + @Deprecated + @Override + public boolean onCommand(CommandSender sender, Command cmd, String lable, String[] args) { + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + if (args.length == 1) { + plugin.getTimer().setMlgActive(false); + if (args[0].equalsIgnoreCase("all")) { + for (Player p : Bukkit.getOnlinePlayers()) { + p.setHealth(p.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue()); + p.setGameMode(GameMode.SURVIVAL); + } + Bukkit.broadcastMessage("§bAlle Spieler wurden wiederbelebt! §aEs kann weiter gehen!"); + } else { + OfflinePlayer other = (Bukkit.getServer().getOfflinePlayer(args[0])); + if (other.isOnline()) { + Player p = (Player) other; + p.setHealth(p.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue()); + p.setGameMode(GameMode.SURVIVAL); + Bukkit.broadcastMessage("§b" + p.getName() + " §awurde von §b" + sender.getName() + " §awiederbelebt!"); + } else + sender.sendMessage("§cDieser Spieler ist nicht online!"); + } + } else if (args.length >= 4) { + World w = Bukkit.getWorld(args[1]); + double x = Double.parseDouble(args[2]); + double y = Double.parseDouble(args[3]); + double z = Double.parseDouble(args[4]); + Location loc = new Location(w, x, y, z); + if (args[0].equalsIgnoreCase("all")) { + for (Player p : Bukkit.getOnlinePlayers()) { + p.teleport(loc); + p.setHealth(p.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue()); + p.setGameMode(GameMode.SURVIVAL); + } + Bukkit.broadcastMessage("§bAlle Spieler wurden bei §c" + w.getName() + " " + x + " " + y + " " + z + " §bwiederbelebt! §aEs kann weiter gehen!"); + } else { + OfflinePlayer other = (Bukkit.getServer().getOfflinePlayer(args[0])); + if (other.isOnline()) { + Player p = (Player) other; + p.teleport(loc); + p.setHealth(p.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue()); + p.setGameMode(GameMode.SURVIVAL); + Bukkit.broadcastMessage("§b" + p.getName() + " §awurde von §b" + sender.getName() + " §abei §c" + w.getName() + " " + x + " " + y + " " + z + " §awiederbelebt!"); + } else + sender.sendMessage("§cDieser Spieler ist nicht online!"); + } + } else + sender.sendMessage("§cBenutze: /revive [world] [x] [y] [z]"); + return true; + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! Nur" + plugin.getCurrentEditor().getName() + " kann Spieler wiederbeleben!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + } +} diff --git a/src/main/java/de/fanta/challenges/commands/settings/SettingsCommandTODO.java b/src/main/java/de/fanta/challenges/commands/settings/SettingsCommandTODO.java new file mode 100644 index 0000000..88ba167 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/settings/SettingsCommandTODO.java @@ -0,0 +1,155 @@ +package de.fanta.challenges.commands.settings; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.guis.settingsgui.MainGui; +import de.fanta.challenges.utils.ChatUtil; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class SettingsCommandTODO implements CommandExecutor { + + + private final Challenges plugin; + + public SettingsCommandTODO(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) { + if (sender instanceof Player) { + Player p = (Player) sender; + if (args.length == 0) { + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + MainGui.createMainGUI(p); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + } + } else if (args.length == 1) { + if (args[0].equalsIgnoreCase("get")) { + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + ChatUtil.sendNormalMessage(p, "Einstellungen"); + ChatUtil.sendNormalMessage(p, "Crafting = " + plugin.getConfig().getBoolean("craftingtable")); + ChatUtil.sendNormalMessage(p, "Villager Handel = " + plugin.getConfig().getBoolean("allowtrading")); + ChatUtil.sendNormalMessage(p, "Sterben bei Fallschaden = " + plugin.getConfig().getBoolean("deathonfall")); + ChatUtil.sendNormalMessage(p, "Schaden beim Schleichen = " + plugin.getConfig().getBoolean("damageonsneak")); + ChatUtil.sendNormalMessage(p, "Schadenswert beim Schleichen = " + plugin.getConfig().getString("sneakdmg")); + ChatUtil.sendNormalMessage(p, "Geteilter Schaden = " + plugin.getConfig().getBoolean("sharedmg")); + ChatUtil.sendNormalMessage(p, "Ein Leben für alle = " + plugin.getConfig().getBoolean("onelife")); + ChatUtil.sendNormalMessage(p, "Schaden im Chat = " + plugin.getConfig().getBoolean("dmginchat")); + ChatUtil.sendNormalMessage(p, "Respawn = " + plugin.getConfig().getBoolean("respawn")); + ChatUtil.sendNormalMessage(p, "MLG " + plugin.getConfig().getBoolean("mlg.enabled")); + ChatUtil.sendNormalMessage(p, "MLG Kill All " + plugin.getConfig().getBoolean("mlg.killall")); + ChatUtil.sendNormalMessage(p, "Maximale Zeit bis zum nächsten MLG = " + plugin.getConfig().getString("mlg.maxtime") + " Sekunden"); + ChatUtil.sendNormalMessage(p, "Sterben beim XP aufheben: " + plugin.getConfig().getBoolean("xpdeath")); + + } else { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + } + } else { + ChatUtil.sendWarningMessage(p, "/settings Get/Crafting/Trading/DeathFall/DMGOnSneak/SneakDMG/RndDrops/ShareDMG/Respawn/OneLife/ChatDMG/MLG/MLGkillall/MLGTime/DeathXP/SprintDeath/JumpDeath [True/False]"); + } + } else { + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + Boolean Bwert = Boolean.parseBoolean(args[1]); + switch (args[0].toLowerCase()) { + case "crafting": + plugin.getConfig().set("craftingtable", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Crafting = " + plugin.getConfig().getBoolean("craftingtable")); + break; + case "deathfall": + plugin.getConfig().set("deathonfall", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Sterben bei Fallschaden = " + plugin.getConfig().getBoolean("deathonfall")); + break; + case "trading": + plugin.getConfig().set("allowtrading", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Villager Handel = " + plugin.getConfig().getBoolean("allowtrading")); + break; + case "dmgonsneak": + plugin.getConfig().set("damageonsneak", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Schaden beim Schleichen = " + plugin.getConfig().getBoolean("damageonsneak")); + break; + case "sneakdmg": + Double Dwert = Double.parseDouble(args[1]); + plugin.getConfig().set("sneakdmg", Dwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Schadenswert beim Schleichen = " + plugin.getConfig().getString("sneakdmg")); + break; + case "rnddrops": + plugin.getConfig().set("rnddrops", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Random Drops = " + plugin.getConfig().getBoolean("rnddrops")); + break; + case "sharedmg": + plugin.getConfig().set("sharehp", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Geteielter Schaden = " + plugin.getConfig().getBoolean("sharedmg")); + case "respawn": + plugin.getConfig().set("respawn", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Respawn = " + plugin.getConfig().getBoolean("respawn")); + break; + case "onelife": + plugin.getConfig().set("onelife", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Ein Leben für alle = " + plugin.getConfig().getBoolean("onelife")); + break; + case "chatdmg": + plugin.getConfig().set("dmginchat", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Schaden im Chat = " + plugin.getConfig().getBoolean("dmginchat")); + break; + case "mlg": + plugin.getConfig().set("mlg.enabled", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "MLG " + plugin.getConfig().getBoolean("mlg.enabled")); + break; + case "mlgkillall": + plugin.getConfig().set("mlg.killall", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "MLG Kill All " + plugin.getConfig().getBoolean("mlg.killall")); + break; + case "mlgtime": + Double time = Double.parseDouble(args[1]); + plugin.getConfig().set("mlg.maxtime", time); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Maximale zeit bis zum nächsten MLG = " + plugin.getConfig().getString("mlg.maxtime") + " Sekunden"); + break; + case "deathxp": + plugin.getConfig().set("xpdeath", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Sterben beim XP aufheben: " + plugin.getConfig().getBoolean("xpdeath")); + break; + case "sprintdeath": + plugin.getConfig().set("deathonsprint", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Sterben durch sprinten: " + plugin.getConfig().getBoolean("deathonsprint")); + break; + case "jumpdeath": + plugin.getConfig().set("deathonjump", Bwert); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Sterben durch springenn: " + plugin.getConfig().getBoolean("deathonjump")); + break; + } + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP Kaufen!"); + return true; + } + } + } else { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + } + return true; + } +} diff --git a/src/main/java/de/fanta/challenges/commands/timer/TimerCommand.java b/src/main/java/de/fanta/challenges/commands/timer/TimerCommand.java new file mode 100644 index 0000000..3ab4809 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/timer/TimerCommand.java @@ -0,0 +1,40 @@ +package de.fanta.challenges.commands.timer; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.fanta.challenges.guis.TimerGui; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class TimerCommand extends SubCommand { + + private final Challenges plugin; + + public TimerCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + Player p = (Player) sender; + TimerGui.createTimerGUI(p); + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return true; + } + +} \ No newline at end of file diff --git a/src/main/java/de/fanta/challenges/commands/timer/TimerPauseCommand.java b/src/main/java/de/fanta/challenges/commands/timer/TimerPauseCommand.java new file mode 100644 index 0000000..63c19b8 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/timer/TimerPauseCommand.java @@ -0,0 +1,49 @@ +package de.fanta.challenges.commands.timer; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.GameRule; +import org.bukkit.World; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class TimerPauseCommand extends SubCommand { + + private final Challenges plugin; + + public TimerPauseCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + if (plugin.getTimer().isRunning()) { + World world = Bukkit.getWorld("world"); + world.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, false); + plugin.getTimer().stopTimer(); + Bukkit.broadcastMessage(Challenges.PREFIX + ChatColor.RED + " Der Timer wurde angehalten"); + } else { + ChatUtil.sendWarningMessage(sender, "Der Timer ist bereits pausiert!"); + } + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return true; + } + +} \ No newline at end of file diff --git a/src/main/java/de/fanta/challenges/commands/timer/TimerResetCommand.java b/src/main/java/de/fanta/challenges/commands/timer/TimerResetCommand.java new file mode 100644 index 0000000..fa17f77 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/timer/TimerResetCommand.java @@ -0,0 +1,41 @@ +package de.fanta.challenges.commands.timer; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class TimerResetCommand extends SubCommand { + + private final Challenges plugin; + + public TimerResetCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + plugin.getTimer().setTime(0); + Bukkit.broadcastMessage(Challenges.PREFIX + ChatColor.RED + " Der Timer wurde zurückgesetzt!"); + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return true; + } + +} diff --git a/src/main/java/de/fanta/challenges/commands/timer/TimerReverseCommand.java b/src/main/java/de/fanta/challenges/commands/timer/TimerReverseCommand.java new file mode 100644 index 0000000..317ba7c --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/timer/TimerReverseCommand.java @@ -0,0 +1,45 @@ +package de.fanta.challenges.commands.timer; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class TimerReverseCommand extends SubCommand { + + private final Challenges plugin; + + public TimerReverseCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + plugin.getTimer().reverseTimer(); + if (plugin.getTimer().isReverse()) { + Bukkit.broadcastMessage(Challenges.PREFIX + ChatColor.AQUA + " Der Timer läuft nun rückwärts!"); + } else { + Bukkit.broadcastMessage(Challenges.PREFIX + ChatColor.GREEN + " Der Timer läuft nun vorwärts!"); + } + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return true; + } + +} diff --git a/src/main/java/de/fanta/challenges/commands/timer/TimerSetCommand.java b/src/main/java/de/fanta/challenges/commands/timer/TimerSetCommand.java new file mode 100644 index 0000000..88c6b2e --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/timer/TimerSetCommand.java @@ -0,0 +1,48 @@ +package de.fanta.challenges.commands.timer; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class TimerSetCommand extends SubCommand { + + private final Challenges plugin; + + public TimerSetCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + if (args.hasNext()) { + int time = args.getNext(-1); + if (time >= 0) { + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + plugin.getTimer().setTime(time); + Bukkit.broadcastMessage(Challenges.PREFIX + " §bDer Timer wurde auf " + plugin.getTimer().formatTime(ChatColor.GREEN) + " §bgesetzt!"); + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + } else { + ChatUtil.sendErrorMessage(sender, "Zeit muss eine Zahl größer als 0 sein!"); + } + return true; + } + return false; + } +} diff --git a/src/main/java/de/fanta/challenges/commands/timer/TimerStartCommand.java b/src/main/java/de/fanta/challenges/commands/timer/TimerStartCommand.java new file mode 100644 index 0000000..b2d34c1 --- /dev/null +++ b/src/main/java/de/fanta/challenges/commands/timer/TimerStartCommand.java @@ -0,0 +1,49 @@ +package de.fanta.challenges.commands.timer; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.iani.cubesideutils.bukkit.commands.SubCommand; +import de.iani.cubesideutils.commands.ArgsParser; +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.GameRule; +import org.bukkit.World; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.entity.Player; + +public class TimerStartCommand extends SubCommand { + + private final Challenges plugin; + + public TimerStartCommand(Challenges plugin) { + this.plugin = plugin; + } + + @Override + public boolean onCommand(CommandSender sender, Command command, String alias, String commandString, ArgsParser args) { + if (!(sender instanceof Player)) { + ChatUtil.sendErrorMessage(sender, "You are not a Player :>"); + return true; + } + if (plugin.isEditor((Player) sender) || sender.hasPermission("Challenges.editor.override")) { + if (!plugin.getTimer().isRunning()) { + World world = Bukkit.getWorld("world"); + world.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, true); + plugin.getTimer().startTimer(); + Bukkit.broadcastMessage(Challenges.PREFIX + ChatColor.GREEN + " Der Timer wird fortgesetzt!"); + } else { + ChatUtil.sendWarningMessage(sender, "Der Timer läuft bereits!"); + } + } else if (plugin.getCurrentEditor() != null) { + ChatUtil.sendErrorMessage(sender, "Du bist kein Editor! " + plugin.getCurrentEditor().getName() + " muss die Map bearbeiten!"); + return true; + } else { + ChatUtil.sendErrorMessage(sender, "Aktuell gibt es keinen Editor!"); + ChatUtil.sendErrorMessage(sender, "Um selbst Editor zu werden musst du dir im Freebuild VIP kaufen!"); + return true; + } + return true; + } + +} diff --git a/src/main/java/de/fanta/challenges/events/PlayerCountChangedEvent.java b/src/main/java/de/fanta/challenges/events/PlayerCountChangedEvent.java new file mode 100644 index 0000000..d94336f --- /dev/null +++ b/src/main/java/de/fanta/challenges/events/PlayerCountChangedEvent.java @@ -0,0 +1,28 @@ +package de.fanta.challenges.events; + +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class PlayerCountChangedEvent extends Event { + + private static final HandlerList handlers = new HandlerList(); + + private int count; + + public PlayerCountChangedEvent(int count) { + this.count = count; + } + + public int getCount() { + return count; + } + + public static HandlerList getHandlerList() { + return handlers; + } + + @Override + public HandlerList getHandlers() { + return handlers; + } +} diff --git a/src/main/java/de/fanta/challenges/events/ServerStatusChangedEvent.java b/src/main/java/de/fanta/challenges/events/ServerStatusChangedEvent.java new file mode 100644 index 0000000..52c306f --- /dev/null +++ b/src/main/java/de/fanta/challenges/events/ServerStatusChangedEvent.java @@ -0,0 +1,28 @@ +package de.fanta.challenges.events; + +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class ServerStatusChangedEvent extends Event { + + private static final HandlerList handlers = new HandlerList(); + + private boolean online; + + public ServerStatusChangedEvent(boolean online) { + this.online = online; + } + + public boolean isOnline() { + return online; + } + + public static HandlerList getHandlerList() { + return handlers; + } + + @Override + public HandlerList getHandlers() { + return handlers; + } +} diff --git a/src/main/java/de/fanta/challenges/events/TimerChangedEvent.java b/src/main/java/de/fanta/challenges/events/TimerChangedEvent.java new file mode 100644 index 0000000..22a0aa0 --- /dev/null +++ b/src/main/java/de/fanta/challenges/events/TimerChangedEvent.java @@ -0,0 +1,28 @@ +package de.fanta.challenges.events; + +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +public class TimerChangedEvent extends Event { + + private static final HandlerList handlers = new HandlerList(); + + private boolean running; + + public TimerChangedEvent(boolean running) { + this.running = running; + } + + public boolean isRunning() { + return running; + } + + public static HandlerList getHandlerList() { + return handlers; + } + + @Override + public HandlerList getHandlers() { + return handlers; + } +} diff --git a/src/main/java/de/fanta/challenges/guis/BackpackGui.java b/src/main/java/de/fanta/challenges/guis/BackpackGui.java new file mode 100644 index 0000000..e7e030b --- /dev/null +++ b/src/main/java/de/fanta/challenges/guis/BackpackGui.java @@ -0,0 +1,102 @@ +package de.fanta.challenges.guis; + +import de.fanta.challenges.Challenges; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.configuration.MemorySection; +import org.bukkit.entity.HumanEntity; +import org.bukkit.entity.Player; +import org.bukkit.inventory.Inventory; +import org.bukkit.inventory.ItemStack; + +import java.io.IOException; +import java.util.Map; +import java.util.logging.Level; + +public class BackpackGui { + + public static final String TITLE = Challenges.GUIPREFIX + " >> Backpack"; + private Inventory backpack; + + public BackpackGui(int size) { + this.backpack = Bukkit.createInventory(null, size, TITLE); + } + + public void resize(int newSize) { + if (newSize == backpack.getSize()) { + return; + } + + Inventory newBackpack = Bukkit.createInventory(backpack.getHolder(), newSize, TITLE); + if (newSize > backpack.getSize()) { + for (int i = 0; i < backpack.getSize(); i++) { + newBackpack.setItem(i, backpack.getItem(i)); + } + } else if (newSize < backpack.getSize()) { + for (int i = 0; i < newSize; i++) { + newBackpack.setItem(i, backpack.getItem(i)); + } + + for (int i = newSize; i < backpack.getSize(); i++) { + ItemStack item = backpack.getItem(i); + if (item != null && item.getType() != Material.AIR) { + if (!newBackpack.addItem(item).isEmpty()) { + Bukkit.broadcastMessage(Challenges.PREFIX + ChatColor.DARK_RED + " Backpack kann nicht verkleinert werden. Zu wenig Platz!"); // TODO COLOR + return; + } + } + } + } + for (HumanEntity player : backpack.getViewers()) { + player.closeInventory(); + } + this.backpack = newBackpack; + } + + public void open(Player player) { + player.openInventory(this.backpack); + } + + public int getSize() { + return this.backpack.getSize(); + } + + public void clearConfig() { + Challenges.getPlugin().getBackpackConfigFile().delete(); + } + + public void saveInventoryToConfig() { + clearConfig(); + for (int slot = 0; slot < backpack.getSize(); slot++) { + ItemStack stack = backpack.getItem(slot); + if (stack != null && stack.getType() != Material.AIR) { + Challenges.getPlugin().getBackpackConfig().set(String.valueOf(slot), stack.serialize()); + } + } + try { + Challenges.getPlugin().getBackpackConfig().save(Challenges.getPlugin().getBackpackConfigFile()); + } catch (IOException e) { + Bukkit.getLogger().log(Level.SEVERE, "Could not save backpack config", e); + } + } + + public void loadInventoryFromConfig() { + for (Map.Entry stringObjectEntry : Challenges.getPlugin().getBackpackConfig().getValues(false).entrySet()) { + int slot; + try { + slot = Integer.parseInt(stringObjectEntry.getKey()); + } catch (NumberFormatException e) { + Bukkit.getLogger().log(Level.SEVERE, "Fehler! Slot: " + stringObjectEntry.getKey(), e); + continue; + } + if (slot >= backpack.getSize()) { + Bukkit.getLogger().log(Level.SEVERE, "Slot " + slot + " befindet sich außerhalb des Inventars!"); + continue; + } + MemorySection memorySection = (MemorySection) stringObjectEntry.getValue(); + ItemStack deserialized = ItemStack.deserialize(memorySection.getValues(false)); + backpack.setItem(slot, deserialized); + } + } +} diff --git a/src/main/java/de/fanta/challenges/guis/ResetGui.java b/src/main/java/de/fanta/challenges/guis/ResetGui.java new file mode 100644 index 0000000..91f4e93 --- /dev/null +++ b/src/main/java/de/fanta/challenges/guis/ResetGui.java @@ -0,0 +1,45 @@ +package de.fanta.challenges.guis; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.guiutils.GUIUtils; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.event.inventory.InventoryType; +import org.bukkit.inventory.Inventory; + +public class ResetGui implements Listener { + + private static final int RESET_INDEX = 2; + + public static final int INVENTORY_SIZE = 5; + public static final Inventory RESET_GUI = Bukkit.createInventory(null, InventoryType.HOPPER, Challenges.GUIPREFIX + " >> Reset"); + + public static void createResetGUI(Player p) { + RESET_GUI.setItem(RESET_INDEX, GUIUtils.createGuiItem(Material.REPEATING_COMMAND_BLOCK, ChatColor.DARK_RED + "Server resetten", ChatColor.RED + "Wenn du denn Server resettest wird", ChatColor.RED + "der Server komplett zurückgesetzt", ChatColor.RED + "und du musst von vorne beginnen!")); + for (int i = 0; i < INVENTORY_SIZE; i++) { + if (RESET_GUI.getItem(i) == null || RESET_GUI.getItem(i).getType() == Material.AIR) { + RESET_GUI.setItem(i, GUIUtils.EMPTY_ICON); + } + } + p.openInventory(RESET_GUI); + } + + @EventHandler + public void onInventoryClick(InventoryClickEvent e) { + int slot = e.getRawSlot(); + Player p = (Player) e.getWhoClicked(); + if (RESET_GUI.equals(e.getClickedInventory())) { + if (slot == RESET_INDEX) { + Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "reset confirm"); + p.closeInventory(); + } + e.setCancelled(true); + } + } +} + diff --git a/src/main/java/de/fanta/challenges/guis/SettingsGui.java b/src/main/java/de/fanta/challenges/guis/SettingsGui.java new file mode 100644 index 0000000..cf51761 --- /dev/null +++ b/src/main/java/de/fanta/challenges/guis/SettingsGui.java @@ -0,0 +1,63 @@ +/*package de.fanta.challenges.guis; + +import de.fanta.challenges.Challenges; +import java.util.ArrayList; +import java.util.List; + +import me.wolfyscript.utilities.api.inventory.GuiUpdateEvent; +import me.wolfyscript.utilities.api.inventory.GuiWindow; +import me.wolfyscript.utilities.api.inventory.InventoryAPI; +import org.bukkit.ChatColor; +import org.bukkit.Material; +import org.bukkit.event.EventHandler; + +public class SettingsGui extends GuiWindow { + + private Challenges challenges = Challenges.getPlugin(); + + public SettingsGui(InventoryAPI inventoryAPI) { + super("settings", inventoryAPI, 54); + } + + @Override + public void onInit() { + registerButton(new SettingButton("craftingtable", Material.CRAFTING_TABLE, "Erlaube Crafting")); + registerButton(new SettingButton("allowtrading", Material.EMERALD, "Erlaube Handeln")); + registerButton(new SettingButton("deathonfall", Material.BONE, "Tod bei Fallschaden", ChatColor.RED + "Spieler stirbt bei Fallschaden")); + registerButton(new SettingButton("damageonsneak", Material.MAGMA_BLOCK, "Schaden bei Schleichen",ChatColor.RED + "Spieler erhält " + challenges.getConfig().getInt("sneakdmg") + " Schaden bei Schleichen")); + registerButton(new SettingButton("rnddrops", Material.DIAMOND_PICKAXE, "Drops", ChatColor.RED + "Random Drops")); + registerButton(new SettingButton("sharedmg", Material.GLISTERING_MELON_SLICE, "Geteilter Schaden",ChatColor.RED + "Alle Spieler erhalten den gleichen Schaden")); + registerButton(new SettingButton("respawn", Material.TOTEM_OF_UNDYING, "Respawn")); + registerButton(new SettingButton("onelife", Material.POPPY, "Ein Leben für alle", ChatColor.RED + "Stirbt ein Spieler ist die", ChatColor.RED + "Challenge fehlgeschlagen")); + registerButton(new SettingButton("dmginchat", Material.BOOK, "Schaden in Chat", ChatColor.RED + "Zeigt Spielerschaden im Chat an")); + registerButton(new SettingButton("deathonsprint", Material.DIAMOND_BOOTS, "Tod bei Sprinten", ChatColor.RED + "Spieler Stirbt beim Sprinten")); + registerButton(new SettingButton("deathonjump", Material.LEATHER_BOOTS, "Tod bei Springen", ChatColor.RED + "Spieler Stirbt beim Springen")); + registerButton(new SettingButton("clinvdmg", Material.BARRIER, "Inv Löschen bei DMG",ChatColor.RED + "Löscht das Inventar von allen wenn ein Spieler schaden bekommt!")); + + registerButton(new SettingButton("tntdeath", Material.TNT, "Sterben durch TnT",ChatColor.RED + "Tötet dich mit tnt bei der nicht Springen Schleichen und Jumpen Challenge")); + registerButton(new SettingButton("xpdeath", Material.ENCHANTING_TABLE, "Sterben durch XP", ChatColor.RED + "Tötet dich wenn du XP einsammelst")); + registerButton(new SettingButton("mlg.enabled", Material.WATER_BUCKET, "MLG", "an aus")); + registerButton(new SettingButton("mlg.killall", Material.WATER_BUCKET, "MLG killall", "an aus")); + registerButton(new SettingButton("wither", Material.NETHER_STAR, "Wither Töten", "Ziel: Töte denn Wither")); + registerButton(new SettingButton("dragon", Material.DRAGON_EGG, "Ender Dragon Töten", "Ziel: Töte denn Ender Dragon")); + + // TODO Gamerules xpdeath + } + + @EventHandler + public void onUpdate(GuiUpdateEvent event) { + + //Other + event.setButton(46, "mlg.killall"); + } + + @Override + protected String getInventoryName() { + return ChatColor.DARK_GREEN + "" + ChatColor.BOLD + "Settings"; + } + + @Override + public List getHelpInformation() { + return new ArrayList<>(); + } +}*/ diff --git a/src/main/java/de/fanta/challenges/guis/TimerGui.java b/src/main/java/de/fanta/challenges/guis/TimerGui.java new file mode 100644 index 0000000..054e4a9 --- /dev/null +++ b/src/main/java/de/fanta/challenges/guis/TimerGui.java @@ -0,0 +1,80 @@ +package de.fanta.challenges.guis; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.guiutils.GUIUtils; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.GameRule; +import org.bukkit.Material; +import org.bukkit.Sound; +import org.bukkit.World; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.inventory.Inventory; + +public class TimerGui implements Listener { + + private static final Challenges plugin = Challenges.getPlugin(); + + public static final int INVENTORY_SIZE = 27; + public static final Inventory TIMER_GUI = Bukkit.createInventory(null, INVENTORY_SIZE, Challenges.GUIPREFIX + " >> Timer"); + + public static void createTimerGUI(Player p) { + + if (plugin.getTimer().isReverse()) { + TIMER_GUI.setItem(11, GUIUtils.createGuiItem(Material.MAGENTA_GLAZED_TERRACOTTA, ChatColor.AQUA + "Timer Richtung - rückwärts")); + } else { + TIMER_GUI.setItem(11, GUIUtils.createGuiItem(Material.MAGENTA_GLAZED_TERRACOTTA, ChatColor.GREEN + "Timer Richtung - vorwärts")); + } + if (plugin.getTimer().isRunning()) { + TIMER_GUI.setItem(15, GUIUtils.createGuiItem(Material.CLOCK, ChatColor.GREEN + "Timer gestartet", true)); + } else { + TIMER_GUI.setItem(15, GUIUtils.createGuiItem(Material.CLOCK, ChatColor.RED + "Timer pausiert")); + } + for (int i = 0; i < INVENTORY_SIZE; i++) { + if (TIMER_GUI.getItem(i) == null || TIMER_GUI.getItem(i).getType() == Material.AIR) { + TIMER_GUI.setItem(i, GUIUtils.EMPTY_ICON); + } + } + p.openInventory(TIMER_GUI); + } + + @EventHandler + public void onInventoryClick(InventoryClickEvent e) { + int slot = e.getRawSlot(); + World world = Bukkit.getWorld("world"); + Player p = (Player) e.getWhoClicked(); + if (e.getInventory() == TIMER_GUI) { + if (slot == 15) { + if (plugin.getTimer().isRunning()) { + plugin.getTimer().stopTimer(); + for (Player pp : Bukkit.getOnlinePlayers()) { + pp.playSound(p.getLocation(), Sound.BLOCK_NOTE_BLOCK_PLING, 1.0F, 2.0F); + world.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, false); + pp.sendTitle(ChatColor.of("#0ddead") + "Timer", ChatColor.RED + "Der Timer wurde pausiert.", 10, 40, 10); + } + } else { + plugin.getTimer().startTimer(); + for (Player pp : Bukkit.getOnlinePlayers()) { + pp.playSound(p.getLocation(), Sound.BLOCK_NOTE_BLOCK_PLING, 1.0F, 2.0F); + world.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, true); + pp.sendTitle(ChatColor.of("#0ddead") + "Timer", ChatColor.GREEN + "Der Timer wurde gestartet.", 10, 60, 10); + } + } + p.closeInventory(); + } else if (slot == 11) { + if (plugin.getTimer().isReverse()) { + plugin.getTimer().reverseTimer(); + GUIUtils.sendTitleToAll("Timer", "Der Timer läuft jetzt vorwärts.", ChatColor.GREEN); + } else { + plugin.getTimer().reverseTimer(); + GUIUtils.sendTitleToAll("Timer", "Der Timer läuft jetzt rückwärts.", ChatColor.AQUA); + } + p.closeInventory(); + } + e.setCancelled(true); + } + } +} diff --git a/src/main/java/de/fanta/challenges/guis/settingsgui/MainGui.java b/src/main/java/de/fanta/challenges/guis/settingsgui/MainGui.java new file mode 100644 index 0000000..5dfd5d9 --- /dev/null +++ b/src/main/java/de/fanta/challenges/guis/settingsgui/MainGui.java @@ -0,0 +1,62 @@ +package de.fanta.challenges.guis.settingsgui; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.guiutils.GUIUtils; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.inventory.Inventory; + +public class MainGui implements Listener { + + private static final Challenges plugin = Challenges.getPlugin(); + + public static final int INVENTORY_SIZE = 27; + public static final Inventory MAIN_GUI = Bukkit.createInventory(null, INVENTORY_SIZE, Challenges.GUIPREFIX + " >> Settings"); + + private static final int CHALLENGES_INDEX = 10; + private static final int OTHER_SETTINGS_INDEX = 13; + private static final int SERVER_SETTINGS_INDEX = 16; + private static final int CLOSE_IDEX = 26; + + public static void createMainGUI(Player p) { + MAIN_GUI.setItem(CHALLENGES_INDEX, GUIUtils.createGuiItem(Material.REPEATER, ChatColor.GREEN + "Challenges")); + MAIN_GUI.setItem(CLOSE_IDEX, GUIUtils.createGuiItem(Material.BARRIER, ChatColor.RED + "Menü verlassen!")); + MAIN_GUI.setItem(SERVER_SETTINGS_INDEX, GUIUtils.createGuiItem(Material.COMMAND_BLOCK, ChatColor.GREEN + "Server Einstellungen")); + MAIN_GUI.setItem(OTHER_SETTINGS_INDEX, GUIUtils.createGuiItem(Material.COMPARATOR, ChatColor.GREEN + "Andere Einstellungen")); + for (int i = 0; i < INVENTORY_SIZE; i++) { + if (MAIN_GUI.getItem(i) == null || MAIN_GUI.getItem(i).getType() == Material.AIR) { + MAIN_GUI.setItem(i, GUIUtils.EMPTY_ICON); + } + } + p.openInventory(MAIN_GUI); + } + + @EventHandler + public void onInventoryClick(InventoryClickEvent e) { + int slot = e.getRawSlot(); + Player p = (Player) e.getWhoClicked(); + if (e.getInventory() == MAIN_GUI) { + switch (slot) { + case CHALLENGES_INDEX: + SettingsGui.createSettingsGUI(p); + break; + case CLOSE_IDEX: + p.closeInventory(); + break; + case SERVER_SETTINGS_INDEX: + ServerSettingsGui.createServerSettingsGUI(p); + break; + case OTHER_SETTINGS_INDEX: + OtherSettingsGui.createOtherSettingsGUI(p); + break; + } + e.setCancelled(true); + } + } +} + diff --git a/src/main/java/de/fanta/challenges/guis/settingsgui/OtherSettingsGui.java b/src/main/java/de/fanta/challenges/guis/settingsgui/OtherSettingsGui.java new file mode 100644 index 0000000..ab06a11 --- /dev/null +++ b/src/main/java/de/fanta/challenges/guis/settingsgui/OtherSettingsGui.java @@ -0,0 +1,133 @@ +package de.fanta.challenges.guis.settingsgui; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.guiutils.GUIUtils; +import de.iani.cubesideutils.bukkit.items.CustomHeads; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.inventory.Inventory; + +public class OtherSettingsGui implements Listener { + + private static final Challenges plugin = Challenges.getPlugin(); + + public static final int INVENTORY_SIZE = 27; + private static final int BACK_INDEX = 18; + private static final int BACKPACK_INDEX = 10; + private static final int DMG_INCHAT_INDEX = 11; + private static final int TNT_DEATH_INDEX = 12; + private static final int TAB_HP_INDEX = 13; + private static final int BACKPACK_ADD_INDEX = 1; + private static final int BACKPACK_REMOVE_INDEX = 19; + + public static final Inventory OTHER_SETTINGS_GUI = Bukkit.createInventory(null, INVENTORY_SIZE, Challenges.GUIPREFIX + " >> Other Settings"); + + private static final int CLOSE_IDEX = 26; + + public static void createOtherSettingsGUI(Player p) { + OTHER_SETTINGS_GUI.setItem(BACKPACK_INDEX, GUIUtils.createGuiItem(Material.LIME_SHULKER_BOX, ChatColor.GREEN + "Rucksack Größe: " + plugin.getBackpack().getSize() / 9 + "/6")); + if (plugin.getBackpack().getSize() < 6 * 9) { + OTHER_SETTINGS_GUI.setItem(BACKPACK_ADD_INDEX, CustomHeads.QUARTZ_ARROW_UP.getHead()); + } else { + OTHER_SETTINGS_GUI.setItem(BACKPACK_ADD_INDEX, GUIUtils.EMPTY_ICON); + } + if (plugin.getBackpack().getSize() > 9) { + OTHER_SETTINGS_GUI.setItem(BACKPACK_REMOVE_INDEX, CustomHeads.QUARTZ_ARROW_DOWN.getHead()); + } else { + OTHER_SETTINGS_GUI.setItem(BACKPACK_REMOVE_INDEX, GUIUtils.EMPTY_ICON); + } + if (plugin.getConfig().getBoolean("dmginchat")) { + OTHER_SETTINGS_GUI.setItem(DMG_INCHAT_INDEX, GUIUtils.createGuiItem(Material.PAPER, ChatColor.GREEN + "Schaden im Chat anzeigen aktiviert", true)); + } else { + OTHER_SETTINGS_GUI.setItem(DMG_INCHAT_INDEX, GUIUtils.createGuiItem(Material.PAPER, ChatColor.RED + "Schaden im Chat anzeigen deaktiviert")); + } + if (p.hasPermission("challenges.event")) { + if (plugin.getConfig().getBoolean("tntdeath")) { + OTHER_SETTINGS_GUI.setItem(TNT_DEATH_INDEX, GUIUtils.createGuiItem(Material.TNT, ChatColor.GREEN + "Sterben durch TNT aktiviert", true, ChatColor.GREEN + "Tötet dich mit TNT bei der \"nicht springen, schleichen und jumpen\" Challenge")); + } else { + OTHER_SETTINGS_GUI.setItem(TNT_DEATH_INDEX, GUIUtils.createGuiItem(Material.TNT, ChatColor.RED + "Sterben durch TNT deaktiviert", ChatColor.RED + "Tötet dich mit TNT bei der \"nicht springen, schleichen und jumpen\" Challenge")); + } + } else { + OTHER_SETTINGS_GUI.setItem(TNT_DEATH_INDEX, GUIUtils.EMPTY_ICON); + } + if (plugin.getConfig().getBoolean("tabhp")) { + OTHER_SETTINGS_GUI.setItem(TAB_HP_INDEX, GUIUtils.createGuiItem(Material.HEART_OF_THE_SEA, ChatColor.GREEN + "Herzen in der Tablist anzeigen aktiviert", true)); + } else { + OTHER_SETTINGS_GUI.setItem(TAB_HP_INDEX, GUIUtils.createGuiItem(Material.HEART_OF_THE_SEA, ChatColor.RED + "Herzen in der Tablist anzeigen deaktiviert")); + } + + OTHER_SETTINGS_GUI.setItem(BACK_INDEX, GUIUtils.createGuiItem(Material.ARROW, ChatColor.GREEN + "Zurück")); + OTHER_SETTINGS_GUI.setItem(CLOSE_IDEX, GUIUtils.createGuiItem(Material.BARRIER, ChatColor.RED + "Menü verlassen!")); + for (int i = 0; i < INVENTORY_SIZE; i++) { + if (OTHER_SETTINGS_GUI.getItem(i) == null || OTHER_SETTINGS_GUI.getItem(i).getType() == Material.AIR) { + OTHER_SETTINGS_GUI.setItem(i, GUIUtils.EMPTY_ICON); + } + } + p.openInventory(OTHER_SETTINGS_GUI); + } + + @EventHandler + public void onInventoryClick(InventoryClickEvent e) { + int slot = e.getRawSlot(); + Player p = (Player) e.getWhoClicked(); + if (e.getInventory() == OTHER_SETTINGS_GUI) { + switch (slot) { + case BACKPACK_ADD_INDEX: + if (plugin.getBackpack().getSize() < 6 * 9) { + plugin.getBackpack().resize(plugin.getBackpack().getSize() + 9); + } + break; + case BACKPACK_REMOVE_INDEX: + if (plugin.getBackpack().getSize() > 9) { + plugin.getBackpack().resize(plugin.getBackpack().getSize() - 9); + } + break; + case DMG_INCHAT_INDEX: + if (plugin.getConfig().getBoolean("dmginchat")) { + GUIUtils.sendTitleToAll("Einstellungen", "Schaden im Chat anzeigen deaktiviert", ChatColor.RED); + GUIUtils.setConfig("dmginchat", false); + } else { + GUIUtils.sendTitleToAll("Einstellungen", "Schaden im Chat anzeigen aktiviert", ChatColor.GREEN); + GUIUtils.setConfig("dmginchat", true); + } + break; + case TNT_DEATH_INDEX: + if (e.getCurrentItem() != null && e.getCurrentItem().getType() == Material.TNT) { + if (plugin.getConfig().getBoolean("tntdeath")) { + GUIUtils.sendTitleToAll("Einstellungen", "Sterben durch TNT deaktiviert", ChatColor.RED); + GUIUtils.setConfig("tntdeath", false); + } else { + GUIUtils.sendTitleToAll("Einstellungen", "Sterben durch TNT aktiviert", ChatColor.GREEN); + GUIUtils.setConfig("tntdeath", true); + } + } + break; + case TAB_HP_INDEX: + if (plugin.getConfig().getBoolean("tabhp")) { + GUIUtils.sendTitleToAll("Einstellungen", "Herzen in der Tablist anzeigen deaktiviert", ChatColor.RED); + GUIUtils.setConfig("tabhp", false); + } else { + GUIUtils.sendTitleToAll("Einstellungen", "Herzen in der Tablist anzeigen aktiviert", ChatColor.GREEN); + GUIUtils.setConfig("tabhp", true); + } + plugin.getSBManager().updateTabHP(); + break; + } + createOtherSettingsGUI(p); + switch (slot) { + case BACK_INDEX: + MainGui.createMainGUI(p); + break; + case CLOSE_IDEX: + p.closeInventory(); + break; + } + e.setCancelled(true); + } + } +} \ No newline at end of file diff --git a/src/main/java/de/fanta/challenges/guis/settingsgui/ServerSettingsGui.java b/src/main/java/de/fanta/challenges/guis/settingsgui/ServerSettingsGui.java new file mode 100644 index 0000000..75fed35 --- /dev/null +++ b/src/main/java/de/fanta/challenges/guis/settingsgui/ServerSettingsGui.java @@ -0,0 +1,178 @@ +package de.fanta.challenges.guis.settingsgui; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.guiutils.GUIUtils; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.Difficulty; +import org.bukkit.GameRule; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.inventory.Inventory; + +public class ServerSettingsGui implements Listener { + + private static final Challenges plugin = Challenges.getPlugin(); + + public static final int INVENTORY_SIZE = 27; + public static final Inventory SERVER_SETTINGS_GUI = Bukkit.createInventory(null, INVENTORY_SIZE, Challenges.GUIPREFIX + " >> Server Settings"); + + private static final int DIFFICULTY_INDEX = 10; + private static final int KEEP_INVENTORY_INDEX = 11; + private static final int NATURAL_REGENERATION_INDEX = 12; + private static final int PVP_INDEX = 16; + private static final int BACK_INDEX = 18; + private static final int CLOSE_INDEX = 26; + private static final int ONE_LIFE_INDEX = 14; + private static final int RESPAWN_INDEX = 15; + + public static void createServerSettingsGUI(Player p) { + if (plugin.getServer().getWorld("world").getDifficulty() == Difficulty.EASY) { + SERVER_SETTINGS_GUI.setItem(DIFFICULTY_INDEX, GUIUtils.createGuiItem(Material.IRON_SWORD, ChatColor.AQUA + "Schwierigkeitsgrad Leicht")); + } else if (plugin.getServer().getWorld("world").getDifficulty() == Difficulty.NORMAL) { + SERVER_SETTINGS_GUI.setItem(DIFFICULTY_INDEX, GUIUtils.createGuiItem(Material.DIAMOND_SWORD, ChatColor.RED + "Schwierigkeitsgrad Mittel")); + } else if (plugin.getServer().getWorld("world").getDifficulty() == Difficulty.HARD) { + SERVER_SETTINGS_GUI.setItem(DIFFICULTY_INDEX, GUIUtils.createGuiItem(Material.NETHERITE_SWORD, ChatColor.DARK_RED + "Schwierigkeitsgrad Schwer")); + } else if (plugin.getServer().getWorld("world").getDifficulty() == Difficulty.PEACEFUL) { + SERVER_SETTINGS_GUI.setItem(DIFFICULTY_INDEX, GUIUtils.createGuiItem(Material.POPPY, ChatColor.GREEN + "Schwierigkeitsgrad Friedlich")); + } + if (plugin.getServer().getWorld("world").getPVP()) { + SERVER_SETTINGS_GUI.setItem(PVP_INDEX, GUIUtils.createGuiItem(Material.WOODEN_SWORD, ChatColor.GREEN + "PVP aktiviert", true)); + } else { + SERVER_SETTINGS_GUI.setItem(PVP_INDEX, GUIUtils.createGuiItem(Material.WOODEN_SWORD, ChatColor.RED + "PVP deaktiviert")); + } + if (plugin.getConfig().getBoolean("onelife")) { + SERVER_SETTINGS_GUI.setItem(ONE_LIFE_INDEX, GUIUtils.createGuiItem(Material.SUNFLOWER, ChatColor.GREEN + "Ein Leben für alle aktiviert", true)); + } else { + SERVER_SETTINGS_GUI.setItem(ONE_LIFE_INDEX, GUIUtils.createGuiItem(Material.SUNFLOWER, ChatColor.RED + "Ein Leben für alle deaktiviert")); + } + if (plugin.getConfig().getBoolean("respawn")) { + SERVER_SETTINGS_GUI.setItem(RESPAWN_INDEX, GUIUtils.createGuiItem(Material.TOTEM_OF_UNDYING, ChatColor.GREEN + "Wiederbeleben aktiviert", true)); + } else { + SERVER_SETTINGS_GUI.setItem(RESPAWN_INDEX, GUIUtils.createGuiItem(Material.TOTEM_OF_UNDYING, ChatColor.RED + "Wiederbeleben deaktiviert")); + } + if (plugin.getServer().getWorld("world").getGameRuleValue(GameRule.KEEP_INVENTORY)) { + SERVER_SETTINGS_GUI.setItem(KEEP_INVENTORY_INDEX, GUIUtils.createGuiItem(Material.CHEST_MINECART,ChatColor.GREEN + "Keep Inventory aktiviert", true)); + } else { + SERVER_SETTINGS_GUI.setItem(KEEP_INVENTORY_INDEX, GUIUtils.createGuiItem(Material.CHEST_MINECART,ChatColor.RED + "Keep Inventory deaktiviert")); + } + if (plugin.getServer().getWorld("world").getGameRuleValue(GameRule.NATURAL_REGENERATION)) { + SERVER_SETTINGS_GUI.setItem(NATURAL_REGENERATION_INDEX, GUIUtils.createGuiItem(Material.GOLDEN_APPLE,ChatColor.GREEN + "Natürliche Regeneration aktiviert", true)); + } else { + SERVER_SETTINGS_GUI.setItem(NATURAL_REGENERATION_INDEX, GUIUtils.createGuiItem(Material.GOLDEN_APPLE,ChatColor.RED + "Natürliche Regeneration deaktiviert")); + } + + SERVER_SETTINGS_GUI.setItem(CLOSE_INDEX, GUIUtils.createGuiItem(Material.BARRIER, ChatColor.RED + "Menü verlassen!")); + SERVER_SETTINGS_GUI.setItem(BACK_INDEX, GUIUtils.createGuiItem(Material.ARROW, ChatColor.GREEN + "Zurück")); + for (int i = 0; i < INVENTORY_SIZE; i++) { + if (SERVER_SETTINGS_GUI.getItem(i) == null || SERVER_SETTINGS_GUI.getItem(i).getType() == Material.AIR) { + SERVER_SETTINGS_GUI.setItem(i, GUIUtils.EMPTY_ICON); + } + } + p.openInventory(SERVER_SETTINGS_GUI); + } + + @EventHandler + public void onInventoryClick(InventoryClickEvent e) { + int slot = e.getRawSlot(); + Player p = (Player) e.getWhoClicked(); + if (e.getInventory() == SERVER_SETTINGS_GUI) { + switch (slot) { + case DIFFICULTY_INDEX: + if (plugin.getServer().getWorld("world").getDifficulty() == Difficulty.EASY) { + plugin.getServer().getWorld("world").setDifficulty(Difficulty.NORMAL); + plugin.getServer().getWorld("world_nether").setDifficulty(Difficulty.NORMAL); + plugin.getServer().getWorld("world_the_end").setDifficulty(Difficulty.NORMAL); + GUIUtils.sendTitleToAll("Server Einstellungen", "Schwierigkeitsgrad Mittel", ChatColor.RED); + } else if (plugin.getServer().getWorld("world").getDifficulty() == Difficulty.NORMAL) { + plugin.getServer().getWorld("world").setDifficulty(Difficulty.HARD); + plugin.getServer().getWorld("world_nether").setDifficulty(Difficulty.HARD); + plugin.getServer().getWorld("world_the_end").setDifficulty(Difficulty.HARD); + GUIUtils.sendTitleToAll("Server Einstellungen", "Schwierigkeitsgrad Schwer", ChatColor.DARK_RED); + } else if (plugin.getServer().getWorld("world").getDifficulty() == Difficulty.HARD) { + plugin.getServer().getWorld("world").setDifficulty(Difficulty.PEACEFUL); + plugin.getServer().getWorld("world_nether").setDifficulty(Difficulty.PEACEFUL); + plugin.getServer().getWorld("world_the_end").setDifficulty(Difficulty.PEACEFUL); + GUIUtils.sendTitleToAll("Server Einstellungen", "Schwierigkeitsgrad Friedlich", ChatColor.GREEN); + } else if (plugin.getServer().getWorld("world").getDifficulty() == Difficulty.PEACEFUL) { + plugin.getServer().getWorld("world").setDifficulty(Difficulty.EASY); + plugin.getServer().getWorld("world_nether").setDifficulty(Difficulty.EASY); + plugin.getServer().getWorld("world_the_end").setDifficulty(Difficulty.EASY); + GUIUtils.sendTitleToAll("Server Einstellungen", "Schwierigkeitsgrad Leicht", ChatColor.AQUA); + } + break; + case PVP_INDEX: + if (plugin.getServer().getWorld("world").getPVP()) { + plugin.getServer().getWorld("world").setPVP(false); + plugin.getServer().getWorld("world_nether").setPVP(false); + plugin.getServer().getWorld("world_the_end").setPVP(false); + GUIUtils.sendTitleToAll("Server Einstellungen", "PVP deaktiviert", ChatColor.RED); + } else { + plugin.getServer().getWorld("world").setPVP(true); + plugin.getServer().getWorld("world_nether").setPVP(true); + plugin.getServer().getWorld("world_the_end").setPVP(true); + GUIUtils.sendTitleToAll("Server Einstellungen", "PVP aktiviert", ChatColor.GREEN); + } + break; + case ONE_LIFE_INDEX: + if (plugin.getConfig().getBoolean("onelife")) { + GUIUtils.setConfig("onelife", false); + GUIUtils.sendTitleToAll("Server Einstellungen", "Ein Leben für alle deaktiviert", ChatColor.RED); + } else { + GUIUtils.setConfig("onelife", true); + GUIUtils.sendTitleToAll("Server Einstellungen", "Ein Leben für alle aktiviert", ChatColor.GREEN); + } + break; + case RESPAWN_INDEX: + if (plugin.getConfig().getBoolean("respawn")) { + GUIUtils.setConfig("respawn", false); + GUIUtils.sendTitleToAll("Server Einstellungen", "Wiederbeleben deaktiviert", ChatColor.RED); + } else { + GUIUtils.setConfig("respawn", true); + GUIUtils.sendTitleToAll("Server Einstellungen", "Wiederbeleben aktiviert", ChatColor.GREEN); + } + break; + case KEEP_INVENTORY_INDEX: + if (plugin.getServer().getWorld("world").getGameRuleValue(GameRule.KEEP_INVENTORY)) { + plugin.getServer().getWorld("world").setGameRule(GameRule.KEEP_INVENTORY, false); + plugin.getServer().getWorld("world_nether").setGameRule(GameRule.KEEP_INVENTORY, false); + plugin.getServer().getWorld("world_the_end").setGameRule(GameRule.KEEP_INVENTORY, false); + GUIUtils.sendTitleToAll("Server Einstellungen", "Keep Inventory deaktiviert", ChatColor.RED); + } else { + plugin.getServer().getWorld("world").setGameRule(GameRule.KEEP_INVENTORY, true); + plugin.getServer().getWorld("world_nether").setGameRule(GameRule.KEEP_INVENTORY, true); + plugin.getServer().getWorld("world_the_end").setGameRule(GameRule.KEEP_INVENTORY, true); + GUIUtils.sendTitleToAll("Server Einstellungen", "Keep Inventory aktiviert", ChatColor.GREEN); + } + break; + case NATURAL_REGENERATION_INDEX: + if (plugin.getServer().getWorld("world").getGameRuleValue(GameRule.NATURAL_REGENERATION)) { + plugin.getServer().getWorld("world").setGameRule(GameRule.NATURAL_REGENERATION, false); + plugin.getServer().getWorld("world_nether").setGameRule(GameRule.NATURAL_REGENERATION, false); + plugin.getServer().getWorld("world_the_end").setGameRule(GameRule.NATURAL_REGENERATION, false); + GUIUtils.sendTitleToAll("Server Einstellungen", "Natürliche Regeneration aktiviert", ChatColor.GREEN); + } else { + plugin.getServer().getWorld("world").setGameRule(GameRule.NATURAL_REGENERATION, true); + plugin.getServer().getWorld("world_nether").setGameRule(GameRule.NATURAL_REGENERATION, true); + plugin.getServer().getWorld("world_the_end").setGameRule(GameRule.NATURAL_REGENERATION, true); + GUIUtils.sendTitleToAll("Server Einstellungen", "Natürliche Regeneration deaktiviert", ChatColor.RED); + } + break; + } + createServerSettingsGUI(p); + + switch (slot) { + case BACK_INDEX: + MainGui.createMainGUI(p); + break; + case CLOSE_INDEX: + p.closeInventory(); + break; + } + e.setCancelled(true); + } + } +} diff --git a/src/main/java/de/fanta/challenges/guis/settingsgui/SettingsGui.java b/src/main/java/de/fanta/challenges/guis/settingsgui/SettingsGui.java new file mode 100644 index 0000000..bf7778d --- /dev/null +++ b/src/main/java/de/fanta/challenges/guis/settingsgui/SettingsGui.java @@ -0,0 +1,264 @@ +package de.fanta.challenges.guis.settingsgui; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.guiutils.GUIUtils; +import de.iani.cubesideutils.bukkit.items.CustomHeads; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.InventoryClickEvent; +import org.bukkit.inventory.Inventory; + +public class SettingsGui implements Listener { + + private static final Challenges plugin = Challenges.getPlugin(); + + public static final int INVENTORY_SIZE = 54; + public static final Inventory SETTINGS_GUI = Bukkit.createInventory(null, INVENTORY_SIZE, Challenges.GUIPREFIX + " >> Challenges"); + + private static final int CRAFTING_TABLE_INDEX = 0; + private static final int TRADING_INDEX = 9; + + private static final int CLOSE_GUI_INDEX = 53; + private static final int BACK_BUTTON_INDEX = 45; + + private static final int XP_DEATH_INDEX = 37; + private static final int DEATH_ON_FALL_INDEX = 38; + private static final int DEATH_ON_SPRINT_INDEX = 39; + private static final int DEATH_ON_JUMP_INDEX = 40; + private static final int CLEANR_INV_BY_DAMAGE_INDEX = 41; + private static final int MLG_INDEX = 42; + private static final int RANDOM_DROP_INDEX = 8; + private static final int SHUFFLE_RANDOM_DROP_INDEX = 17; + private static final int TARGET_INDEX = 4; + private static final int SHARE_DMG_INDEX = 28; + + private static final int DMG_ON_SNEAK_INDEX = 43; + private static final int DMG_ON_SNEAK_ADD_INDEX = 34; + private static final int DMG_ON_SNEAK_REMOVE_INDEX = 52; + + public static void createSettingsGUI(Player p) { + if (plugin.getConfig().getBoolean("craftingtable")) { + SETTINGS_GUI.setItem(CRAFTING_TABLE_INDEX, GUIUtils.createGuiItem(Material.CRAFTING_TABLE, ChatColor.GREEN + "Werkbank aktiviert", true)); + } else { + SETTINGS_GUI.setItem(CRAFTING_TABLE_INDEX, GUIUtils.createGuiItem(Material.CRAFTING_TABLE, ChatColor.RED + "Werkbank deaktiviert")); + } + if (plugin.getConfig().getBoolean("allowtrading")) { + SETTINGS_GUI.setItem(TRADING_INDEX, GUIUtils.createGuiItem(Material.VILLAGER_SPAWN_EGG, ChatColor.GREEN + "Handeln aktiviert", true)); + } else { + SETTINGS_GUI.setItem(TRADING_INDEX, GUIUtils.createGuiItem(Material.VILLAGER_SPAWN_EGG, ChatColor.RED + "Handeln deaktiviert")); + } + if (plugin.getConfig().getBoolean("xpdeath")) { + SETTINGS_GUI.setItem(XP_DEATH_INDEX, GUIUtils.createGuiItem(Material.ENCHANTING_TABLE, ChatColor.GREEN + "Sterben durch XP aktiviert", true, ChatColor.GREEN + "Wenn ein Spieler XP einsammelt wird er sterben")); + } else { + SETTINGS_GUI.setItem(XP_DEATH_INDEX, GUIUtils.createGuiItem(Material.ENCHANTING_TABLE, ChatColor.RED + "Sterben durch XP deaktiviert", ChatColor.RED + "Wenn ein Spieler XP einsammelt wird er sterben")); + } + if (plugin.getConfig().getBoolean("deathonfall")) { + SETTINGS_GUI.setItem(DEATH_ON_FALL_INDEX, GUIUtils.createGuiItem(Material.NETHERITE_BOOTS, ChatColor.GREEN + "Tod bei Fallschaden aktiviert", true)); + } else { + SETTINGS_GUI.setItem(DEATH_ON_FALL_INDEX, GUIUtils.createGuiItem(Material.NETHERITE_BOOTS, ChatColor.RED + "Tod bei Fallschaden deaktiviert")); + } + if (plugin.getConfig().getBoolean("rnddrops")) { + SETTINGS_GUI.setItem(RANDOM_DROP_INDEX, GUIUtils.createGuiItem(Material.NETHERITE_PICKAXE, ChatColor.GREEN + "Zufällige Drops aktiviert", true)); + } else { + SETTINGS_GUI.setItem(RANDOM_DROP_INDEX, GUIUtils.createGuiItem(Material.NETHERITE_PICKAXE, ChatColor.RED + "Zufällige Drops deaktiviert")); + } + if (plugin.getConfig().getBoolean("deathonsprint")) { + SETTINGS_GUI.setItem(DEATH_ON_SPRINT_INDEX, GUIUtils.createGuiItem(Material.POTION, ChatColor.GREEN + "Tod beim Sprinten aktiviert", true)); + } else { + SETTINGS_GUI.setItem(DEATH_ON_SPRINT_INDEX, GUIUtils.createGuiItem(Material.GLASS_BOTTLE, ChatColor.RED + "Tod beim Sprinten deaktiviert")); + } + if (plugin.getConfig().getBoolean("deathonjump")) { + SETTINGS_GUI.setItem(DEATH_ON_JUMP_INDEX, GUIUtils.createGuiItem(Material.RABBIT_FOOT, ChatColor.GREEN + "Tod beim Springen aktiviert", true)); + } else { + SETTINGS_GUI.setItem(DEATH_ON_JUMP_INDEX, GUIUtils.createGuiItem(Material.RABBIT_FOOT, ChatColor.RED + "Tod beim Springen deaktiviert")); + } + if (plugin.getConfig().getBoolean("target")) { + SETTINGS_GUI.setItem(TARGET_INDEX, GUIUtils.createGuiItem(Material.DRAGON_HEAD, ChatColor.GREEN + "Ziel: Enderdrachen töten")); + } else { + SETTINGS_GUI.setItem(TARGET_INDEX, GUIUtils.createGuiItem(Material.WITHER_SKELETON_SKULL, ChatColor.GREEN + "Ziel: Wither töten")); + } + if (plugin.getConfig().getBoolean("clinvdmg")) { + SETTINGS_GUI.setItem(CLEANR_INV_BY_DAMAGE_INDEX, GUIUtils.createGuiItem(Material.BARRIER, ChatColor.GREEN + "Alle Inventare löschen wenn ein Spieler Schaden bekommt aktiviert", true)); + } else { + SETTINGS_GUI.setItem(CLEANR_INV_BY_DAMAGE_INDEX, GUIUtils.createGuiItem(Material.BARRIER, ChatColor.RED + "Alle Inventare löschen wenn ein Spieler Schaden bekommt deaktiviert")); + } + if (plugin.getConfig().getBoolean("damageonsneak")) { + SETTINGS_GUI.setItem(DMG_ON_SNEAK_INDEX, GUIUtils.createGuiItem(Material.SMOOTH_STONE_SLAB, ChatColor.GREEN + "Schaden beim Schleichen aktiviert", true, ChatColor.GREEN + "Schaden beim Schleichen: " + plugin.getConfig().getDouble("sneakdmg"))); + SETTINGS_GUI.setItem(DMG_ON_SNEAK_ADD_INDEX, CustomHeads.QUARTZ_ARROW_UP.getHead()); + SETTINGS_GUI.setItem(DMG_ON_SNEAK_REMOVE_INDEX, CustomHeads.QUARTZ_ARROW_DOWN.getHead()); + + } else { + SETTINGS_GUI.setItem(DMG_ON_SNEAK_INDEX, GUIUtils.createGuiItem(Material.SMOOTH_STONE_SLAB, ChatColor.RED + "Schaden beim Schleichen deaktiviert")); + SETTINGS_GUI.setItem(DMG_ON_SNEAK_ADD_INDEX, GUIUtils.EMPTY_ICON); + SETTINGS_GUI.setItem(DMG_ON_SNEAK_REMOVE_INDEX, GUIUtils.EMPTY_ICON); + } + if (plugin.getConfig().getBoolean("mlg.enabled")) { + SETTINGS_GUI.setItem(MLG_INDEX, GUIUtils.createGuiItem(Material.WATER_BUCKET, ChatColor.GREEN + "MLG aktiviert", true)); + } else { + SETTINGS_GUI.setItem(MLG_INDEX, GUIUtils.createGuiItem(Material.WATER_BUCKET, ChatColor.RED + "MLG deaktiviert")); + } + if (plugin.getConfig().getBoolean("sharedmg")) { + SETTINGS_GUI.setItem(SHARE_DMG_INDEX, GUIUtils.createGuiItem(Material.MELON_SLICE, ChatColor.GREEN + "Geteilter Schaden aktiviert", true)); + } else { + SETTINGS_GUI.setItem(SHARE_DMG_INDEX, GUIUtils.createGuiItem(Material.MELON_SLICE, ChatColor.RED + "Geteilter Schaden deaktiviert")); + } + SETTINGS_GUI.setItem(SHUFFLE_RANDOM_DROP_INDEX, GUIUtils.createGuiItem(Material.CHORUS_FLOWER, ChatColor.GREEN + "Zufällige Drops neu mischen")); + SETTINGS_GUI.setItem(CLOSE_GUI_INDEX, GUIUtils.createGuiItem(Material.BARRIER, ChatColor.RED + "Menü verlassen!")); + SETTINGS_GUI.setItem(BACK_BUTTON_INDEX, GUIUtils.createGuiItem(Material.ARROW, ChatColor.GREEN + "Zurück")); + for (int i = 0; i < INVENTORY_SIZE; i++) { + if (SETTINGS_GUI.getItem(i) == null || SETTINGS_GUI.getItem(i).getType() == Material.AIR) { + SETTINGS_GUI.setItem(i, GUIUtils.EMPTY_ICON); + } + } + p.openInventory(SETTINGS_GUI); + } + + @EventHandler + public void onInventoryClick(InventoryClickEvent e) { + if (e.getInventory() != SETTINGS_GUI) { + return; + } + int slot = e.getRawSlot(); + Player p = (Player) e.getWhoClicked(); + switch (slot) { + case CRAFTING_TABLE_INDEX: + if (plugin.getConfig().getBoolean("craftingtable")) { + GUIUtils.setConfig("craftingtable", false); + GUIUtils.sendTitleToAll("Challenge", "Werkbank deaktiviert", ChatColor.RED); + } else { + GUIUtils.setConfig("craftingtable", true); + GUIUtils.sendTitleToAll("Challenge", "Werkbank aktiviert", ChatColor.GREEN); + } + break; + + case TRADING_INDEX: + if (plugin.getConfig().getBoolean("allowtrading")) { + GUIUtils.setConfig("allowtrading", false); + GUIUtils.sendTitleToAll("Challenge", "Handeln deaktiviert", ChatColor.RED); + } else { + GUIUtils.setConfig("allowtrading", true); + GUIUtils.sendTitleToAll("Challenge", "Handeln aktiviert", ChatColor.GREEN); + } + break; + case XP_DEATH_INDEX: + if (plugin.getConfig().getBoolean("xpdeath")) { + GUIUtils.setConfig("xpdeath", false); + GUIUtils.sendTitleToAll("Challenge", "Sterben durch Einsammeln von XP deaktiviert", ChatColor.RED); + } else { + GUIUtils.setConfig("xpdeath", true); + GUIUtils.sendTitleToAll("Challenge", "Sterben durch Einsammeln von XP aktiviert", ChatColor.GREEN); + } + break; + case DEATH_ON_FALL_INDEX: + if (plugin.getConfig().getBoolean("deathonfall")) { + GUIUtils.setConfig("deathonfall", false); + GUIUtils.sendTitleToAll("Challenge", "Sterben durch Fallschaden deaktiviert", ChatColor.RED); + } else { + GUIUtils.sendTitleToAll("Challenge", "Sterben durch Fallschaden aktiviert", ChatColor.GREEN); + GUIUtils.setConfig("deathonfall", true); + } + break; + case RANDOM_DROP_INDEX: + if (plugin.getConfig().getBoolean("rnddrops")) { + GUIUtils.setConfig("rnddrops", false); + GUIUtils.sendTitleToAll("Challenge", "Zufällige Drops deaktiviert", ChatColor.RED); + } else { + GUIUtils.sendTitleToAll("Challenge", "Zufällige Drops aktiviert", ChatColor.GREEN); + GUIUtils.setConfig("rnddrops", true); + } + break; + case SHUFFLE_RANDOM_DROP_INDEX: + plugin.rndDrops.shuffleItems(); + GUIUtils.sendTitleToAll("Challenge", "Zufällige Drops neu gemischt!", ChatColor.GREEN); + break; + case DEATH_ON_SPRINT_INDEX: + if (plugin.getConfig().getBoolean("deathonsprint")) { + GUIUtils.setConfig("deathonsprint", false); + GUIUtils.sendTitleToAll("Challenge", "Sterben durch Sprinten deaktiviert", ChatColor.RED); + } else { + GUIUtils.sendTitleToAll("Challenge", "Sterben durch Sprinten aktiviert", ChatColor.GREEN); + GUIUtils.setConfig("deathonsprint", true); + } + break; + case DEATH_ON_JUMP_INDEX: + if (plugin.getConfig().getBoolean("deathonjump")) { + GUIUtils.setConfig("deathonjump", false); + GUIUtils.sendTitleToAll("Challenge", "Sterben durch Springen deaktiviert", ChatColor.RED); + } else { + GUIUtils.sendTitleToAll("Challenge", "Sterben durch Springen aktiviert", ChatColor.GREEN); + GUIUtils.setConfig("deathonjump", true); + } + break; + case TARGET_INDEX: + if (plugin.getConfig().getBoolean("target")) { + GUIUtils.setConfig("target", false); + GUIUtils.sendTitleToAll("Challenge", "Ziel: Töte den Wither", ChatColor.GREEN); + } else { + GUIUtils.sendTitleToAll("Challenge", "Ziel: Töte den Enderdrachen", ChatColor.GREEN); + GUIUtils.setConfig("target", true); + } + break; + case CLEANR_INV_BY_DAMAGE_INDEX: + if (plugin.getConfig().getBoolean("clinvdmg")) { + GUIUtils.setConfig("clinvdmg", false); + GUIUtils.sendTitleToAll("Challenge", "Inventar von allen löschen wenn einer Schaden bekommt deaktiviert", ChatColor.RED); + } else { + GUIUtils.sendTitleToAll("Challenge", "Inventar von allen löschen wenn einer Schaden bekommt aktiviert", ChatColor.GREEN); + GUIUtils.setConfig("clinvdmg", true); + } + break; + case DMG_ON_SNEAK_INDEX: + if (plugin.getConfig().getBoolean("damageonsneak")) { + GUIUtils.setConfig("damageonsneak", false); + GUIUtils.sendTitleToAll("Challenge", "Schaden bekommen beim Schleichen deaktiviert", ChatColor.RED); + } else { + GUIUtils.sendTitleToAll("Challenge", "Schaden bekommen beim Schleichen aktiviert", ChatColor.GREEN); + GUIUtils.setConfig("damageonsneak", true); + } + break; + case MLG_INDEX: + if (plugin.getConfig().getBoolean("mlg.enabled")) { + GUIUtils.setConfig("mlg.enabled", false); + GUIUtils.sendTitleToAll("Challenge", "MLG deaktiviert", ChatColor.RED); + } else { + GUIUtils.sendTitleToAll("Challenge", "MLG aktiviert", ChatColor.GREEN); + GUIUtils.setConfig("mlg.enabled", true); + } + break; + case DMG_ON_SNEAK_ADD_INDEX: + GUIUtils.setConfig("sneakdmg", plugin.getConfig().getDouble("sneakdmg") + 0.5); + break; + case DMG_ON_SNEAK_REMOVE_INDEX: + if (plugin.getConfig().getDouble("sneakdmg") > 0) { + GUIUtils.setConfig("sneakdmg", plugin.getConfig().getDouble("sneakdmg") - 0.5); + } + break; + case SHARE_DMG_INDEX: + if (plugin.getConfig().getBoolean("sharedmg")) { + GUIUtils.setConfig("sharedmg", false); + GUIUtils.sendTitleToAll("Challenge", "Geteielter Schaden deaktiviert", ChatColor.RED); + } else { + GUIUtils.setConfig("sharedmg", true); + GUIUtils.sendTitleToAll("Challenge", "Geteielter Schaden aktiviert", ChatColor.GREEN); + } + break; + + default: + break; + } + createSettingsGUI(p); + switch (slot) { + case CLOSE_GUI_INDEX: + p.closeInventory(); + break; + case BACK_BUTTON_INDEX: + MainGui.createMainGUI(p); + break; + } + e.setCancelled(true); + } +} \ No newline at end of file diff --git a/src/main/java/de/fanta/challenges/listeners/BlockCreateListener.java b/src/main/java/de/fanta/challenges/listeners/BlockCreateListener.java new file mode 100644 index 0000000..3345b7d --- /dev/null +++ b/src/main/java/de/fanta/challenges/listeners/BlockCreateListener.java @@ -0,0 +1,27 @@ +package de.fanta.challenges.listeners; + +import de.fanta.challenges.Challenges; +import org.bukkit.GameMode; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockPlaceEvent; +import org.bukkit.event.player.PlayerBucketEmptyEvent; + +public class BlockCreateListener implements Listener { + + private Challenges plugin = Challenges.getPlugin(); + + @EventHandler + public void onBlockPlace(BlockPlaceEvent e) { + if (!plugin.getTimer().isRunning() && e.getPlayer().getGameMode() == GameMode.SURVIVAL) { + e.setCancelled(true); + } + } + + @EventHandler + public void onBucketPlace(PlayerBucketEmptyEvent e) { + if (!plugin.getTimer().isRunning() && e.getPlayer().getGameMode() == GameMode.SURVIVAL) { + e.setCancelled(true); + } + } +} diff --git a/src/main/java/de/fanta/challenges/listeners/BlockDestroyListener.java b/src/main/java/de/fanta/challenges/listeners/BlockDestroyListener.java new file mode 100644 index 0000000..4ba6b22 --- /dev/null +++ b/src/main/java/de/fanta/challenges/listeners/BlockDestroyListener.java @@ -0,0 +1,55 @@ +package de.fanta.challenges.listeners; + +import de.fanta.challenges.Challenges; +import org.bukkit.GameMode; +import org.bukkit.Material; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockBreakEvent; +import org.bukkit.event.block.BlockExplodeEvent; +import org.bukkit.event.entity.EntityExplodeEvent; +import org.bukkit.inventory.ItemStack; + +public class BlockDestroyListener implements Listener { + + private Challenges plugin = Challenges.getPlugin(); + + @EventHandler + public void onBlockBreak(BlockBreakEvent e) { + if (this.plugin.getConfig().getBoolean("rnddrops") && plugin.getTimer().isRunning()) { + e.setDropItems(false); + e.getBlock().getWorld().dropItem(e.getBlock().getLocation().add(0.5D, 0.5D, 0.5D), new ItemStack(this.plugin.getRandomDropsManager().getMaterialFromBlock(e.getBlock()))); + } + if ((!plugin.getTimer().isRunning()) && e.getPlayer().getGameMode() == GameMode.SURVIVAL) { + e.setCancelled(true); + } + } + + @EventHandler + public void onBlockExplode(BlockExplodeEvent e) { + if (this.plugin.getConfig().getBoolean("rnddrops")) { + e.blockList().forEach(block -> { + if(!block.getType().isAir()){ + block.getWorld().dropItem(block.getLocation().add(0.5D, 0.5D, 0.5D),new ItemStack(this.plugin.getRandomDropsManager().getMaterialFromBlock(block))); + block.setType(Material.AIR); + } + }); + e.blockList().clear(); + } + } + + @EventHandler + public void onEntityExplode(EntityExplodeEvent e) { + if (this.plugin.getConfig().getBoolean("rnddrops")) { + e.blockList().forEach(block -> { + if(!block.getType().isAir()){ + block.getWorld().dropItem(block.getLocation().add(0.5D, 0.5D, 0.5D),new ItemStack(this.plugin.getRandomDropsManager().getMaterialFromBlock(block))); + block.setType(Material.AIR); + } + }); + e.blockList().clear(); + } + } + +} + diff --git a/src/main/java/de/fanta/challenges/listeners/DamageListener.java b/src/main/java/de/fanta/challenges/listeners/DamageListener.java new file mode 100644 index 0000000..0cf86c7 --- /dev/null +++ b/src/main/java/de/fanta/challenges/listeners/DamageListener.java @@ -0,0 +1,203 @@ +package de.fanta.challenges.listeners; + +import com.destroystokyo.paper.event.player.PlayerJumpEvent; +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import java.text.DecimalFormat; + +import org.bukkit.Bukkit; +import org.bukkit.GameMode; +import org.bukkit.Location; +import org.bukkit.Sound; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.Player; +import org.bukkit.entity.TNTPrimed; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDamageByEntityEvent; +import org.bukkit.event.entity.EntityDamageEvent; +import org.bukkit.event.entity.EntityDamageEvent.DamageCause; +import org.bukkit.event.player.PlayerExpChangeEvent; +import org.bukkit.event.player.PlayerToggleSneakEvent; +import org.bukkit.event.player.PlayerToggleSprintEvent; + +public class DamageListener implements Listener { + + private Challenges plugin = Challenges.getPlugin(); + + @EventHandler + public void onDamage(EntityDamageEvent e) { + if (e.getEntity() instanceof Player) { + Player p = (Player) e.getEntity(); + String dmg = new DecimalFormat("#.##").format(e.getFinalDamage()); + if (e.getFinalDamage() > 0) { + if (e.getCause() == DamageCause.FALL) { + if (plugin.getConfig().getBoolean("deathonfall")) { + if (plugin.getConfig().getBoolean("dmginchat")) { + Bukkit.broadcastMessage(Challenges.PREFIX + " " + ChatUtil.PLAYER + p.getName() + ChatUtil.NORMAL + " hat " + ChatUtil.WARNING + dmg + ChatUtil.NORMAL + " HP Schaden genommen durch " + ChatUtil.WARNING + e.getCause()); + } + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> p.setHealth(0), 1); + } else if (plugin.getConfig().getBoolean("dmginchat") && (plugin.getTimer().isRunning())) { + Bukkit.broadcastMessage(Challenges.PREFIX + " " + ChatUtil.PLAYER + p.getName() + ChatUtil.NORMAL + " hat " + ChatUtil.WARNING + dmg + ChatUtil.NORMAL + " HP Schaden genommen durch " + ChatUtil.WARNING + e.getCause()); + } + } else if (e.getCause() == DamageCause.CUSTOM) { + if (!p.isSneaking() && (plugin.getConfig().getBoolean("dmginchat"))) { + Bukkit.broadcastMessage(Challenges.PREFIX + " " + ChatUtil.PLAYER + p.getName() + ChatUtil.NORMAL + " hat " + ChatUtil.WARNING + plugin.getConfig().getDouble("sneakdmg") + ChatUtil.NORMAL + " HP Schaden genommen durch" + ChatUtil.WARNING + " SNEAKING"); + } + } else if (e.getCause() == DamageCause.ENTITY_ATTACK || e.getCause() == DamageCause.ENTITY_EXPLOSION) { + + } else if (plugin.getConfig().getBoolean("dmginchat") && (plugin.getTimer().isRunning())) { + Bukkit.broadcastMessage(Challenges.PREFIX + " " + ChatUtil.PLAYER + p.getName() + ChatUtil.NORMAL + " hat " + ChatUtil.WARNING + dmg + ChatUtil.NORMAL + " HP Schaden genommen durch " + ChatUtil.WARNING + e.getCause()); + } + if (plugin.getConfig().getBoolean("sharedmg") && plugin.getTimer().isRunning()) { + for (Player pp : Bukkit.getOnlinePlayers()) { + if (pp != p) { + double health = pp.getHealth() - e.getFinalDamage(); + if (health < 0) { + pp.setHealth(0); + } else { + if (pp.getGameMode() == GameMode.SURVIVAL) { + pp.setHealth(health); + pp.getWorld().playSound(pp.getLocation(), Sound.ENTITY_PLAYER_HURT, 1, 1); + } + + } + + } + } + } + } + } + if (!plugin.getTimer().isRunning()) { + e.setCancelled(true); + } + } + + @EventHandler + public void onEntityDamage(EntityDamageByEntityEvent e) { + if ((e.getEntity() instanceof Player) && (e.getFinalDamage() > 0) && (plugin.getTimer().isRunning())) { + Player p = (Player) e.getEntity(); + String dmg = new DecimalFormat("#.##").format(e.getFinalDamage()); + if ((e.getCause() == DamageCause.ENTITY_ATTACK || e.getCause() == DamageCause.ENTITY_EXPLOSION) && plugin.getConfig().getBoolean("dmginchat")) { + Bukkit.broadcastMessage(Challenges.PREFIX + " " + ChatUtil.PLAYER + p.getName() + ChatUtil.NORMAL + " hat " + ChatUtil.WARNING + dmg + ChatUtil.NORMAL + " HP Schaden genommen durch " + ChatUtil.WARNING + e.getDamager().getName()); + } + } + if (!plugin.getTimer().isRunning()) { + e.setCancelled(true); + } + } + + @EventHandler + public void onPlayerSneak(PlayerToggleSneakEvent e) { + Player p = e.getPlayer(); + if (plugin.getTimer().isRunning() && e.getPlayer().getGameMode() == GameMode.SURVIVAL) { + if (!p.isSneaking()) { + if (plugin.getConfig().getBoolean("damageonsneak")) { + if (plugin.getConfig().getBoolean("tntdeath")) { + for (Player pp : Bukkit.getOnlinePlayers()) { + pp.sendTitle("§c" + p.getName() + " §ahat gesneakt!", "§b:>", 5, 50, 5); + EntityType tnt = EntityType.PRIMED_TNT; + Location loc = pp.getLocation(); + TNTPrimed PRIME_TNT = (TNTPrimed) pp.getWorld().spawnEntity(loc, tnt); + PRIME_TNT.setCustomName("§c§lNUKE"); + PRIME_TNT.setFuseTicks(15); + PRIME_TNT.setYield(120); + PRIME_TNT.setIsIncendiary(true); + } + } else { + p.damage(plugin.getConfig().getDouble("sneakdmg")); + } + } + } + } + } + + @EventHandler + public void onPlayerSprint(PlayerToggleSprintEvent e) { + Player p = e.getPlayer(); + if (plugin.getTimer().isRunning() && e.getPlayer().getGameMode() == GameMode.SURVIVAL) { + if (!p.isSprinting()) { + if (plugin.getConfig().getBoolean("deathonsprint")) { + if (plugin.getConfig().getBoolean("tntdeath")) { + for (Player pp : Bukkit.getOnlinePlayers()) { + pp.sendTitle("§c" + p.getName() + " §aist gesprintet!", "§bBOOOM :>", 5, 50, 5); + EntityType tnt = EntityType.PRIMED_TNT; + Location loc = pp.getLocation(); + TNTPrimed PRIME_TNT = (TNTPrimed) pp.getWorld().spawnEntity(loc, tnt); + PRIME_TNT.setCustomName("§c§lNUKE"); + PRIME_TNT.setFuseTicks(15); + PRIME_TNT.setYield(120); + PRIME_TNT.setIsIncendiary(true); + } + } else { + p.setHealth(0); + } + } + } + } + } + + @EventHandler + public void onPlayerJump(PlayerJumpEvent e) { + Player p = e.getPlayer(); + if (plugin.getTimer().isRunning() && e.getPlayer().getGameMode() == GameMode.SURVIVAL) { + if (plugin.getConfig().getBoolean("deathonjump")) { + if (plugin.getConfig().getBoolean("tntdeath")) { + for (Player pp : Bukkit.getOnlinePlayers()) { + pp.sendTitle("§c" + p.getName() + " §aist gesprungen!", "§bBOOOM :>", 5, 50, 5); + EntityType tnt = EntityType.PRIMED_TNT; + Location loc = pp.getLocation(); + TNTPrimed PRIME_TNT = (TNTPrimed) pp.getWorld().spawnEntity(loc, tnt); + PRIME_TNT.setCustomName("§c§lNUKE"); + PRIME_TNT.setFuseTicks(15); + PRIME_TNT.setYield(120); + PRIME_TNT.setIsIncendiary(true); + } + } else { + p.setHealth(0); + } + } + } + } + + @EventHandler + public void onDamageclear(EntityDamageEvent e) { + if (e.getEntity() instanceof Player) { + Player p = (Player) e.getEntity(); + if (e.getEntity() instanceof Player) { + if (plugin.getConfig().getBoolean("clinvdmg")) { + if (plugin.getTimer().isRunning() && p.getGameMode() == GameMode.SURVIVAL) { + for (Player pp : Bukkit.getOnlinePlayers()) { + pp.getInventory().clear(); + ChatUtil.sendNormalMessage(pp, ChatUtil.PLAYER + p.getName() + ChatUtil.WARNING + " hat Schaden bekommen! Alle Inventare wurden gelöscht!"); + + } + } + } + } + } + } + + @EventHandler + public void onPlayerGetXP(PlayerExpChangeEvent e) { + Player p = e.getPlayer(); + if (plugin.getTimer().isRunning() && e.getPlayer().getGameMode() == GameMode.SURVIVAL) { + if (plugin.getConfig().getBoolean("xpdeath")) { + if (plugin.getConfig().getBoolean("tntdeath")) { + for (Player pp : Bukkit.getOnlinePlayers()) { + pp.sendTitle("§c" + p.getName() + " §ahat XP eingesammelt!", "§bPling :>", 5, 50, 5); + EntityType tnt = EntityType.PRIMED_TNT; + Location loc = pp.getLocation(); + TNTPrimed PRIME_TNT = (TNTPrimed) pp.getWorld().spawnEntity(loc, tnt); + PRIME_TNT.setCustomName("§c§lNUKE"); + PRIME_TNT.setFuseTicks(15); + PRIME_TNT.setYield(120); + PRIME_TNT.setIsIncendiary(true); + } + } else { + p.setHealth(0); + } + } + } + } +} diff --git a/src/main/java/de/fanta/challenges/listeners/DeathListener.java b/src/main/java/de/fanta/challenges/listeners/DeathListener.java new file mode 100644 index 0000000..f61de08 --- /dev/null +++ b/src/main/java/de/fanta/challenges/listeners/DeathListener.java @@ -0,0 +1,66 @@ +package de.fanta.challenges.listeners; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.GameMode; +import org.bukkit.entity.EnderDragon; +import org.bukkit.entity.Player; +import org.bukkit.entity.Wither; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDeathEvent; +import org.bukkit.event.entity.PlayerDeathEvent; +import org.bukkit.event.player.PlayerRespawnEvent; + +public class DeathListener implements Listener { + + private Challenges plugin = Challenges.getPlugin(); + + @EventHandler + public void onPlayerDeath(PlayerDeathEvent e) { + if (plugin.getConfig().getBoolean("onelife")) { + plugin.getTimer().stopTimer(); + for (Player p : Bukkit.getOnlinePlayers()) { + p.setGameMode(GameMode.SPECTATOR); + } + e.setDeathMessage(Challenges.PREFIX + " " + ChatUtil.PLAYER + e.getEntity().getName() + ChatUtil.NORMAL + " ist gestorben!"); + Bukkit.broadcastMessage("§cVerschwendete Zeit §6" + plugin.getTimer().formatTime(ChatColor.GOLD)); + Bukkit.broadcastMessage("§aWelt Seed: §b" + Bukkit.getWorlds().get(0).getSeed()); + Bukkit.broadcastMessage("§6Um alle wiederzubeleben benutze §c/revive ALL"); + } else { + e.setDeathMessage(Challenges.PREFIX + " " + ChatUtil.PLAYER + e.getEntity().getName() + ChatUtil.NORMAL + " ist gestorben! " + ChatUtil.WARNING + "(" + e.getEntity().getLocation().getBlockX() + " " + e.getEntity().getLocation().getBlockY() + " " + e.getEntity().getLocation().getBlockZ() + ")"); + if (!plugin.getConfig().getBoolean("respawn")) { + Player editor = plugin.getCurrentEditor(); + ChatUtil.sendNormalMessage(editor, "§6Benutze §c/revive " + e.getEntity().getName() + " [world] [x] [y] [z] §6um ihn wiederzubeleben!"); + } + } + } + + @EventHandler + public void onPlayerRespawn(PlayerRespawnEvent e) { + if (!plugin.getConfig().getBoolean("respawn")) { + e.getPlayer().sendTitle(ChatUtil.NORMAL + "Du bist gestorben!", ChatUtil.ERROR + "Du bist nun Zuschauer", 10, 80, 10); + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> e.getPlayer().setGameMode(GameMode.SPECTATOR), 1); + } + } + + @EventHandler + public void DragonDeath(EntityDeathEvent e) { + if ((e.getEntity() instanceof EnderDragon && plugin.getConfig().getBoolean("target")) || (e.getEntity() instanceof Wither && !plugin.getConfig().getBoolean("target"))) { + plugin.getTimer().stopTimer(); + Bukkit.broadcastMessage(Challenges.PREFIX + ChatColor.GREEN + ChatColor.BOLD + ChatColor.MAGIC + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); + Bukkit.broadcastMessage(Challenges.PREFIX); + Bukkit.broadcastMessage(Challenges.PREFIX); + Bukkit.broadcastMessage(Challenges.PREFIX); + Bukkit.broadcastMessage(Challenges.PREFIX + " §8>> §7Der §2§l" + e.getEntity().getName().toLowerCase() + " §7wurde besiegt."); + Bukkit.broadcastMessage(Challenges.PREFIX + " §8>> §7Benötigte Zeit: §2§l" + plugin.getTimer().formatTime(ChatColor.GREEN) + "§7!"); + Bukkit.broadcastMessage(Challenges.PREFIX + " §8>> §7Seed: §2§l" + Bukkit.getWorlds().get(0).getSeed()); + Bukkit.broadcastMessage(Challenges.PREFIX); + Bukkit.broadcastMessage(Challenges.PREFIX); + Bukkit.broadcastMessage(Challenges.PREFIX); + Bukkit.broadcastMessage(Challenges.PREFIX + ChatColor.GREEN + ChatColor.BOLD + ChatColor.MAGIC + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); + } + } +} diff --git a/src/main/java/de/fanta/challenges/listeners/InteractListener.java b/src/main/java/de/fanta/challenges/listeners/InteractListener.java new file mode 100644 index 0000000..74b9a08 --- /dev/null +++ b/src/main/java/de/fanta/challenges/listeners/InteractListener.java @@ -0,0 +1,43 @@ +package de.fanta.challenges.listeners; + +import de.fanta.challenges.Challenges; +import org.bukkit.GameMode; +import org.bukkit.Material; +import org.bukkit.entity.EntityType; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; +import org.bukkit.event.player.PlayerInteractEntityEvent; +import org.bukkit.event.player.PlayerInteractEvent; + +public class InteractListener implements Listener { + + private final Challenges plugin = Challenges.getPlugin(); + + @EventHandler + public void onBlockClick(PlayerInteractEvent e) { + if (e.getAction() == Action.RIGHT_CLICK_BLOCK) { + if (e.getClickedBlock().getType() == Material.CRAFTING_TABLE) { + if (!plugin.getConfig().getBoolean("craftingtable")) { + e.setCancelled(true); + } + } + if (!plugin.getTimer().isRunning() && e.getPlayer().getGameMode() != GameMode.CREATIVE) { + e.setCancelled(true); + } + } + } + + @EventHandler + public void onEntityClick(PlayerInteractEntityEvent e) { + if (e.getRightClicked().getType() == EntityType.VILLAGER) { + if (!plugin.getConfig().getBoolean("allowtrading")) { + e.setCancelled(true); + } + } + if (!plugin.getTimer().isRunning() && e.getPlayer().getGameMode() != GameMode.CREATIVE) { + e.setCancelled(true); + } + } +} + diff --git a/src/main/java/de/fanta/challenges/listeners/InventoryClickListener.java b/src/main/java/de/fanta/challenges/listeners/InventoryClickListener.java new file mode 100644 index 0000000..27f6c72 --- /dev/null +++ b/src/main/java/de/fanta/challenges/listeners/InventoryClickListener.java @@ -0,0 +1,44 @@ +package de.fanta.challenges.listeners; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.utils.ChatUtil; +import de.fanta.challenges.commands.coords.CoordsCommand; +import de.fanta.challenges.commands.coords.CoordsDeleteCommand; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.inventory.InventoryClickEvent; + +public class InventoryClickListener implements Listener { + + private final Challenges plugin = Challenges.getPlugin(); + + @EventHandler + public void InvClick(InventoryClickEvent e) { + String invname = e.getView().getTitle(); + Player p = (Player) e.getWhoClicked(); + int slot = e.getRawSlot(); + if (invname.equals(CoordsCommand.CGUIN)) { + e.setCancelled(true); + if (slot >= 0 && slot <= 44) { + if (CoordsCommand.CoordsGUI.getItem(slot) != null && p.hasPermission("challenges.coords.delete")) { + p.performCommand("coords delete " + e.getCurrentItem().getItemMeta().getDisplayName()); + } + } + } + if (invname.equals(CoordsDeleteCommand.CDGUIN)) { + e.setCancelled(true); + if (slot == 0) { + String cname = CoordsDeleteCommand.CoordsDeleteGUI.getItem(4).getItemMeta().getDisplayName(); + plugin.getConfig().set("Saved_Locations." + cname, null); + plugin.saveConfig(); + ChatUtil.sendNormalMessage(p, "Position " + cname + " wurde gelöscht!"); + p.closeInventory(); + } + if (slot == 8) { + p.performCommand("coords"); + } + } + } +} + diff --git a/src/main/java/de/fanta/challenges/listeners/PlayerListener.java b/src/main/java/de/fanta/challenges/listeners/PlayerListener.java new file mode 100644 index 0000000..29eedb1 --- /dev/null +++ b/src/main/java/de/fanta/challenges/listeners/PlayerListener.java @@ -0,0 +1,27 @@ +package de.fanta.challenges.listeners; + +import de.fanta.challenges.Challenges; +import de.fanta.challenges.commands.event.EventToggleCommand; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityTargetLivingEntityEvent; +import org.bukkit.event.entity.FoodLevelChangeEvent; + +public class PlayerListener implements Listener { + + private final Challenges plugin = Challenges.getPlugin(); + + @EventHandler + public void onEntityTarget(EntityTargetLivingEntityEvent e) { + if (!plugin.getTimer().isRunning()) { + e.setCancelled(true); + } + } + + @EventHandler + public void onFoodChange(FoodLevelChangeEvent e) { + if (!plugin.getTimer().isRunning()) { + e.setCancelled(true); + } + } +} diff --git a/src/main/java/de/fanta/challenges/listeners/QuitJoinListener.java b/src/main/java/de/fanta/challenges/listeners/QuitJoinListener.java new file mode 100644 index 0000000..42c2e8d --- /dev/null +++ b/src/main/java/de/fanta/challenges/listeners/QuitJoinListener.java @@ -0,0 +1,117 @@ +package de.fanta.challenges.listeners; + +import de.fanta.challenges.Challenges; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; +import java.util.stream.Collectors; + +import de.fanta.challenges.events.PlayerCountChangedEvent; +import de.fanta.challenges.events.ServerStatusChangedEvent; +import de.fanta.challenges.utils.ChatUtil; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.event.player.PlayerLoginEvent; +import org.bukkit.event.player.PlayerQuitEvent; + +public class QuitJoinListener implements Listener { + + private final Challenges plugin = Challenges.getPlugin(); + private int resetTaskId = -1; + + @EventHandler + public void onPlayerJoin(PlayerJoinEvent e) { + Player p = e.getPlayer();; + if (resetTaskId > 0) { + Bukkit.getScheduler().cancelTask(resetTaskId); + resetTaskId = -1; + } + + + Bukkit.broadcastMessage(Challenges.PREFIX + " " + ChatUtil.PLAYER + p.getName() + ChatUtil.NORMAL + " hat die Lobby betreten! " + ChatColor.of("#E4E737") + "[" + Bukkit.getServer().getOnlinePlayers().size() + "/" + Bukkit.getServer().getMaxPlayers() + "]"); + e.setJoinMessage(null); + if (plugin.getConfig().getBoolean("sharedmg")) { + int rnd = new Random().nextInt(Bukkit.getOnlinePlayers().size()); + Player rp = (Player) Bukkit.getServer().getOnlinePlayers().toArray()[rnd]; + p.setHealth(rp.getHealth()); + } + + this.plugin.getSBManager().setScoreboard(p); + + if (plugin.getCurrentEditor() == null) { + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> { + if (p.hasPermission("Challenges.editor")) { + plugin.setCurrentEditor(p); + ChatUtil.sendNormalMessage(p, "Du bist nun der Editor dieser Lobby!"); + } else { + ChatUtil.sendWarningMessage(p, "Es ist aktuell kein Editor in dieser Lobby"); + ChatUtil.sendWarningMessage(p, "Um selbst Editor zu werden musst du VIP sein!"); + } + }, 1L); + } else { + ChatUtil.sendNormalMessage(p, plugin.getCurrentEditor().getName() + " ist der Editor dieser Lobby!"); + } + + Bukkit.getPluginManager().callEvent(new PlayerCountChangedEvent(Bukkit.getOnlinePlayers().size())); + } + + @EventHandler + public void onPlayerLogin(PlayerLoginEvent e) { + if (plugin.isWaitingForShutdown()) { + e.setResult(PlayerLoginEvent.Result.KICK_OTHER); + e.setKickMessage("Der Server wird gerade neu gestartet."); + } + } + + @EventHandler + public void onPlayerQuit(PlayerQuitEvent e) { + Player player = e.getPlayer(); + Bukkit.broadcastMessage(Challenges.PREFIX + " " + ChatColor.of("#3D98DC") + player.getName() + ChatColor.of("#C45B3D") + " hat die Lobby verlassen! " + ChatColor.of("#E4E737") + "[" + (Bukkit.getServer().getOnlinePlayers().size() - 1) + "/" + Bukkit.getServer().getMaxPlayers() + "]"); + e.setQuitMessage(null); + + if (Bukkit.getOnlinePlayers().size() == 1) { + plugin.getTimer().stopTimer(); + } + + if (plugin.getCurrentEditor() != null && player.getUniqueId().equals(plugin.getCurrentEditor().getUniqueId())) { + if (Bukkit.getServer().getOnlinePlayers().size() - 1 > 0) { + Random random = new Random(); + Player randomPlayer; + + List onlinePlayersWithPermission = Bukkit.getOnlinePlayers().stream().filter(p -> p.hasPermission("Challenges.editor")).distinct().collect(Collectors.toList()); + onlinePlayersWithPermission.remove(player); + if (onlinePlayersWithPermission.size() > 0) { + int rnd = random.nextInt(onlinePlayersWithPermission.size()); + randomPlayer = onlinePlayersWithPermission.get(rnd); + } else { + List onlinePlayers = new ArrayList<>(Bukkit.getOnlinePlayers()); + onlinePlayers.remove(player); + int rnd = random.nextInt(onlinePlayers.size()); + randomPlayer = onlinePlayers.get(rnd); + } + plugin.setCurrentEditor(randomPlayer); + ChatUtil.sendNormalMessage(randomPlayer, "Du bist nun der Editor dieser Lobby!"); + Bukkit.broadcastMessage(Challenges.PREFIX + " " + ChatColor.GREEN + randomPlayer.getName() + " ist nun der Editor dieser Lobby!"); + } else { + plugin.setCurrentEditor(null); + + resetTaskId = Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> { + Bukkit.dispatchCommand(Bukkit.getConsoleSender() ,"reset confirm"); + }, 10 * 60 * 20); + } + } + + Bukkit.getPluginManager().callEvent(new PlayerCountChangedEvent(Bukkit.getOnlinePlayers().size() - 1)); + + if (plugin.isWaitingForShutdown() && Bukkit.getOnlinePlayers().size() == 1) { + Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, () -> { + Bukkit.getPluginManager().callEvent(new ServerStatusChangedEvent(false)); + }, 1L); + } + } +} diff --git a/src/main/java/de/fanta/challenges/scoreboard/ScoreBoardManager.java b/src/main/java/de/fanta/challenges/scoreboard/ScoreBoardManager.java new file mode 100644 index 0000000..96d5fb9 --- /dev/null +++ b/src/main/java/de/fanta/challenges/scoreboard/ScoreBoardManager.java @@ -0,0 +1,104 @@ +package de.fanta.challenges.scoreboard; + +import de.fanta.challenges.Challenges; +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.entity.Player; +import org.bukkit.entity.Strider; +import org.bukkit.scoreboard.DisplaySlot; +import org.bukkit.scoreboard.Objective; +import org.bukkit.scoreboard.RenderType; +import org.bukkit.scoreboard.Score; +import org.bukkit.scoreboard.Scoreboard; +import org.bukkit.scoreboard.ScoreboardManager; +import org.bukkit.scoreboard.Team; + +public class ScoreBoardManager { + + private final Challenges plugin; + private Scoreboard scoreboard; + private Team team; + + private Objective event; + private Objective tabHP; + + public ScoreBoardManager(Challenges plugin) { + this.plugin = plugin; + } + + private void initScoreboard() { // only possible after first world has loaded + this.scoreboard = Bukkit.getScoreboardManager().getNewScoreboard(); + this.team = scoreboard.registerNewTeam("Player"); + + this.team.setColor(ChatColor.GREEN); + + updateTabHP(); + } + + public void setScoreboard(Player p) { + if (this.scoreboard == null) { + initScoreboard(); + } + + team.addEntry(p.getName()); + + p.setScoreboard(scoreboard); + } + + public void updateTabHP() { + if (plugin.getConfig().getBoolean("tabhp")) { + if (this.tabHP == null) { + tabHP = scoreboard.registerNewObjective("hp", "health", "§6Challenges"); + } + tabHP.setDisplaySlot(DisplaySlot.PLAYER_LIST); + tabHP.setDisplayName("§cHP"); + tabHP.setRenderType(RenderType.HEARTS); + + for (String entry : team.getEntries()) { + Player player = Bukkit.getPlayer(entry); + if (player != null) { + tabHP.getScore(entry).setScore((int) player.getHealth()); + } + } + + } else { + if (tabHP != null) { + tabHP.unregister(); + tabHP = null; + } + } + } + + public void updateEventScoreboard() { + if (plugin.getConfig().getBoolean("event")) { + this.team.setColor(ChatColor.BLUE); + this.team.setDisplayName("Event"); + + if (this.event == null) { + event = this.scoreboard.registerNewObjective("event", "event", "§6Challenges"); + } + event.setDisplaySlot(DisplaySlot.SIDEBAR); + event.setDisplayName(team.getColor() + team.getPrefix() + team.getDisplayName()); + event.setRenderType(RenderType.INTEGER); + + for (String entry : team.getEntries()) { + event.getScore(entry).setScore(0); + } + + } else { + if (event != null) { + event.unregister(); + event = null; + } + this.team.setColor(ChatColor.GREEN); + this.team.setDisplayName("Player"); + } + } + + void updateEventScore(Player player, int difference) { + if (this.event != null) { + Score score = event.getScore(player.getName()); + score.setScore(score.getScore() + difference); + } + } +} diff --git a/src/main/java/de/fanta/challenges/scoreboard/ScoreManager.java b/src/main/java/de/fanta/challenges/scoreboard/ScoreManager.java new file mode 100644 index 0000000..d06c435 --- /dev/null +++ b/src/main/java/de/fanta/challenges/scoreboard/ScoreManager.java @@ -0,0 +1,39 @@ +package de.fanta.challenges.scoreboard; + +import de.fanta.challenges.Challenges; +import org.bukkit.entity.Player; + +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; + +public class ScoreManager { + + private final Challenges plugin; + private final Map scores; + + public ScoreManager(Challenges plugin) { + this.plugin = plugin; + this.scores = new HashMap<>(); + } + + public void updateScore(Player player, int difference) { + int score = scores.getOrDefault(player.getUniqueId(), 0); + score += difference; + scores.put(player.getUniqueId(), score); + + this.plugin.getSBManager().updateEventScore(player, difference); + } + + public int getScore(Player player) { + return scores.getOrDefault(player.getUniqueId(), -1); + } + + public void saveScores() { + // TODO wenn man will, scores in Datei schreiben + } + + public Map getScores() { + return scores; + } +} diff --git a/src/main/java/de/fanta/challenges/utils/ChatUtil.java b/src/main/java/de/fanta/challenges/utils/ChatUtil.java new file mode 100644 index 0000000..2561da5 --- /dev/null +++ b/src/main/java/de/fanta/challenges/utils/ChatUtil.java @@ -0,0 +1,34 @@ +package de.fanta.challenges.utils; + +import de.fanta.challenges.Challenges; +import de.iani.cubesideutils.bukkit.ChatUtilBukkit; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.command.CommandSender; + +public class ChatUtil { + + public static final ChatColor NORMAL = ChatColor.of("#1FFF00"); + public static final ChatColor WARNING = ChatColor.of("#ffe100"); + public static final ChatColor ERROR = ChatColor.of("#a30202"); + public static final ChatColor PLAYER = ChatColor.of("#3D98DC"); + + private ChatUtil() { + // prevent instances + } + + public static void sendMessage(CommandSender sender, String colors, Object message, Object... messageParts) { + ChatUtilBukkit.sendMessage(sender, Challenges.PREFIX, colors, message, messageParts); + } + + public static void sendNormalMessage(CommandSender sender, Object message, Object... messageParts) { + sendMessage(sender, NORMAL.toString(), message, messageParts); + } + + public static void sendWarningMessage(CommandSender sender, Object message, Object... messageParts) { + sendMessage(sender, WARNING.toString(), message, messageParts); + } + + public static void sendErrorMessage(CommandSender sender, Object message, Object... messageParts) { + sendMessage(sender, ERROR.toString(), message, messageParts); + } +} diff --git a/src/main/java/de/fanta/challenges/utils/guiutils/GUIUtils.java b/src/main/java/de/fanta/challenges/utils/guiutils/GUIUtils.java new file mode 100644 index 0000000..474b16b --- /dev/null +++ b/src/main/java/de/fanta/challenges/utils/guiutils/GUIUtils.java @@ -0,0 +1,50 @@ +package de.fanta.challenges.utils.guiutils; + +import de.fanta.challenges.Challenges; +import net.md_5.bungee.api.ChatColor; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.Sound; +import org.bukkit.enchantments.Enchantment; +import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemFlag; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; + +import java.util.Arrays; + +public class GUIUtils { + + private static final Challenges plugin = Challenges.getPlugin(); + + public static final ItemStack EMPTY_ICON = createGuiItem(Material.GRAY_STAINED_GLASS_PANE, "§1", true); + + public static ItemStack createGuiItem(Material material, String name, String... lore) { + return createGuiItem(material, name, false, lore); + } + + public static ItemStack createGuiItem(final Material material, final String name, boolean glowing, final String... lore) { + final ItemStack item = new ItemStack(material, 1); + final ItemMeta meta = item.getItemMeta(); + meta.setDisplayName(name); + meta.setLore(Arrays.asList(lore)); + if (glowing) { + meta.addEnchant(Enchantment.MENDING, 1, false); + meta.addItemFlags(ItemFlag.HIDE_ENCHANTS); + } + item.setItemMeta(meta); + return item; + } + + public static void sendTitleToAll(String headline, String text, ChatColor textColor) { + for (Player p : Bukkit.getOnlinePlayers()) { + p.playSound(p.getLocation(), Sound.BLOCK_NOTE_BLOCK_PLING, 1.0F, 2.0F); + p.sendTitle(ChatColor.of("#0ddead") + headline, textColor + text, 10, 60, 10); + } + } + + public static void setConfig(String path, Object value) { + plugin.getConfig().set(path, value); + plugin.saveConfig(); + } +} diff --git a/src/main/java/net/brennholz/challenges/Backpack.java b/src/main/java/net/brennholz/challenges/Backpack.java deleted file mode 100644 index 3f3a23b..0000000 --- a/src/main/java/net/brennholz/challenges/Backpack.java +++ /dev/null @@ -1,75 +0,0 @@ -package net.brennholz.challenges; - -import java.util.Iterator; -import java.util.Map; -import org.bukkit.Bukkit; -import org.bukkit.Material; -import org.bukkit.command.Command; -import org.bukkit.command.CommandExecutor; -import org.bukkit.command.CommandSender; -import org.bukkit.configuration.MemorySection; -import org.bukkit.entity.Player; -import org.bukkit.inventory.Inventory; -import org.bukkit.inventory.ItemStack; - -public class Backpack implements CommandExecutor { - private Challenges chl = Challenges.getplugin(); - private static Challenges chl1 = Challenges.getplugin(); - - static int size = chl1.getConfig().getInt("backpack_size"); - public static Inventory Backpack = Bukkit.createInventory(null, size, "§6Backpack"); - - public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) { - if (sender instanceof Player) { - Player p = (Player) sender; - if (p.hasPermission("challenges.backpack")) { - p.openInventory(Backpack); - } else { - p.sendMessage("hast hierfkeine Berechtigung"); - } - } else { - sender.sendMessage("Konsolenbefehl!"); - } - return true; - } - - public void clearConfig() { - Iterator var2 = this.chl.getBackpackConfig().getKeys(false).iterator(); - while (var2.hasNext()) { - String main_path = (String) var2.next(); - this.chl.getBackpackConfig().set(main_path, null); - } - } - - public void saveInventoryToConfig() { - clearConfig(); - int slot = 0; - for (; slot < Backpack.getSize(); slot++) { - ItemStack stack = Backpack.getItem(slot); - if (stack != null && stack.getType() != Material.AIR) - this.chl.getBackpackConfig().set(String.valueOf(slot), stack.serialize()); - } - } - - @SuppressWarnings("rawtypes") - public void loadInventoryFromConfig() { - Iterator var2 = this.chl.getBackpackConfig().getValues(false).entrySet().iterator(); - while (var2.hasNext()) { - int slot; - Map.Entry entry = (Map.Entry) var2.next(); - try { - slot = Integer.parseInt((String) entry.getKey()); - } catch (NumberFormatException var6) { - this.chl.getServer().broadcastMessage("Fehler! Slot: " + (String) entry.getKey()); - continue; - } - if (slot >= Backpack.getSize()) { - this.chl.getServer().broadcastMessage("" + slot + " befindet sich audes Inventars!"); - continue; - } - MemorySection memorySection = (MemorySection) entry.getValue(); - ItemStack deserialized = ItemStack.deserialize(memorySection.getValues(false)); - Backpack.setItem(slot, deserialized); - } - } -} diff --git a/src/main/java/net/brennholz/challenges/Challenges.java b/src/main/java/net/brennholz/challenges/Challenges.java deleted file mode 100644 index edca76e..0000000 --- a/src/main/java/net/brennholz/challenges/Challenges.java +++ /dev/null @@ -1,281 +0,0 @@ -package net.brennholz.challenges; - -import net.brennholz.commands.Challenges_Command; -import net.brennholz.commands.Coords_Command; -import net.brennholz.commands.HP_Command; -import net.brennholz.commands.Reset_Command; -import net.brennholz.commands.Revive_Command; -import net.brennholz.commands.Settings_Command; -import net.brennholz.commands.Timer_Command; -import net.brennholz.events.BlockCreateListener; -import net.brennholz.events.BlockDestroyListener; -import net.brennholz.events.DamageListener; -import net.brennholz.events.DeathListener; -import net.brennholz.events.InteractListener; -import net.brennholz.events.InventoryClickListener; -import net.brennholz.events.QuitJoinListener; -import java.io.File; -import java.io.IOException; -import java.util.ArrayList; -import org.bukkit.Bukkit; -import org.bukkit.Material; -import org.bukkit.World; -import org.bukkit.configuration.file.FileConfiguration; -import org.bukkit.configuration.file.YamlConfiguration; -import org.bukkit.entity.Player; -import org.bukkit.inventory.Inventory; -import org.bukkit.inventory.ItemStack; -import org.bukkit.inventory.meta.ItemMeta; -import org.bukkit.plugin.Plugin; -import org.bukkit.plugin.java.JavaPlugin; - -import com.google.common.io.MoreFiles; -import com.google.common.io.RecursiveDeleteOption; - -public class Challenges extends JavaPlugin { - private static Challenges plugin; - - private File BackpackConfigFile; - - private FileConfiguration BackpackConfig; - - private File RndDropsConfigFile; - - private FileConfiguration RndDropsConfig; - - private Timer_Command Timer; - - private Backpack backpack; - - private SBManager sbManager; - - private RandomDrops rndDrops; - - public static Inventory SettingsGUI = Bukkit.createInventory(null, 45, "§6Settings"); - - public static String GUIName = "§6Settings"; - - public static Challenges getplugin() { return plugin; } - - - public void onEnable() { - plugin = this; - this.Timer = new Timer_Command(); - this.backpack = new Backpack(); - this.rndDrops = new RandomDrops(); - getCommand("hp").setExecutor(new HP_Command()); - getCommand("settings").setExecutor(new Settings_Command()); - getCommand("coords").setExecutor(new Coords_Command()); - getCommand("revive").setExecutor(new Revive_Command()); - getCommand("timer").setExecutor(new Timer_Command()); - getCommand("challenges").setExecutor(new Challenges_Command()); - getCommand("backpack").setExecutor(new Backpack()); - getCommand("reset").setExecutor(new Reset_Command()); - - Bukkit.getPluginManager().registerEvents(new InventoryClickListener(), (Plugin)this); - Bukkit.getPluginManager().registerEvents(new QuitJoinListener(), (Plugin)this); - Bukkit.getPluginManager().registerEvents(new BlockDestroyListener(), (Plugin)this); - Bukkit.getPluginManager().registerEvents(new BlockCreateListener(), (Plugin)this); - Bukkit.getPluginManager().registerEvents(new InteractListener(), (Plugin)this); - Bukkit.getPluginManager().registerEvents(new DamageListener(), (Plugin)this); - Bukkit.getPluginManager().registerEvents(new DeathListener(), (Plugin)this); - - saveDefaultConfig(); - reloadConfig(); - createRndDropsConfig(); - createBackpackConfig(); - if (getConfig().getBoolean("World_Reset")) { - getLogger().info("/Reset Command was executed!"); - getLogger().info("Preparing world reset!"); - String worldname = getConfig().getString("World_Name"); - String nethername = worldname + "_nether"; - String endname = worldname + "_the_end"; - File worldfolder = new File(Bukkit.getWorldContainer().getPath() + "/" + worldname); - File netherfolder = new File(Bukkit.getWorldContainer().getPath() + "/" + nethername); - File endfolder = new File(Bukkit.getWorldContainer().getPath() + "/" + endname); - try { - MoreFiles.deleteRecursively(worldfolder.toPath(), new RecursiveDeleteOption[] { RecursiveDeleteOption.ALLOW_INSECURE }); - MoreFiles.deleteRecursively(netherfolder.toPath(), new RecursiveDeleteOption[] { RecursiveDeleteOption.ALLOW_INSECURE }); - MoreFiles.deleteRecursively(endfolder.toPath(), new RecursiveDeleteOption[] { RecursiveDeleteOption.ALLOW_INSECURE }); - getLogger().info("World reset successful!"); - } catch (IOException e) { - getLogger().info("World reset failed!"); - e.printStackTrace(); - } - getConfig().set("World_Reset", Boolean.valueOf(false)); - saveConfig(); - this.backpack.clearConfig(); - this.rndDrops.shuffleItems(); - this.rndDrops.saveItems(); - this.rndDrops.loadItems(); - } else { - this.rndDrops.loadItems(); - } - this.backpack.loadInventoryFromConfig(); - this.Timer.Run_Timer(); - getLogger().info("Plugin loaded!"); - this.sbManager = new SBManager(); - } - - - - public void onDisable() { - this.backpack.saveInventoryToConfig(); - try { - this.BackpackConfig.save(this.BackpackConfigFile); - this.RndDropsConfig.save(this.RndDropsConfigFile); - } catch (IOException e) { - e.printStackTrace(); - } - getLogger().info("Plugin unloaded"); - } - - public RandomDrops getRandomDropsManager() { - return this.rndDrops; - } - - public FileConfiguration getBackpackConfig() { - return this.BackpackConfig; - } - - private void createBackpackConfig() { - this.BackpackConfigFile = new File(getDataFolder(), "backpack.yml"); - if (!this.BackpackConfigFile.exists()) { - this.BackpackConfigFile.getParentFile().mkdirs(); - saveResource("backpack.yml", false); - } - this.BackpackConfig = (FileConfiguration)new YamlConfiguration(); - try { - this.BackpackConfig.load(this.BackpackConfigFile); - } catch (IOException|org.bukkit.configuration.InvalidConfigurationException e) { - e.printStackTrace(); - } - } - - public FileConfiguration getRndDropsConfig() { - return this.RndDropsConfig; - } - - private void createRndDropsConfig() { - this.RndDropsConfigFile = new File(getDataFolder(), "rnddrops.yml"); - if (!this.RndDropsConfigFile.exists()) { - this.RndDropsConfigFile.getParentFile().mkdirs(); - saveResource("rnddrops.yml", false); - } - this.RndDropsConfig = (FileConfiguration)new YamlConfiguration(); - try { - this.RndDropsConfig.load(this.RndDropsConfigFile); - } catch (IOException|org.bukkit.configuration.InvalidConfigurationException e) { - e.printStackTrace(); - } - } - - - - public void createGUI(Player p) { - SettingsGUI.setItem(0, addGUIItem(Material.CRAFTING_TABLE, "§6Erlaube Crafting")); - SettingsGUI.setItem(1, addGUIItem(Material.EMERALD, "§6Erlaube Handeln")); - SettingsGUI.setItem(2, addGUIItem(Material.BONE, "§6Tod bei Fallschaden", "§cSpieler stirbt bei Fallschaden")); - SettingsGUI.setItem(3, addGUIItem(Material.MAGMA_BLOCK, "§6Schaden bei Schleichen","§cSpieler erhält §6" + getConfig().getInt("sneakdmg") + " §cSchaden bei Schleichen")); - SettingsGUI.setItem(4, addGUIItem(Material.DIAMOND_PICKAXE, "§6Drops", "§cRandom Drops")); - SettingsGUI.setItem(5, addGUIItem(Material.GLISTERING_MELON_SLICE, "§6Geteilter Schaden","§cAlle Spieler erhalten den gleichen Schaden")); - SettingsGUI.setItem(6, addGUIItem(Material.TOTEM_OF_UNDYING, "§6Respawn")); - SettingsGUI.setItem(7, addGUIItem(Material.POPPY, "§6Ein Leben für alle", "§cStirbt ein Spieler ist die","§cChallenge fehlgeschlagen")); - SettingsGUI.setItem(8, addGUIItem(Material.BOOK, "§6Schaden in Chat", "§cZeigt Spielerschaden im Chat an")); - SettingsGUI.setItem(18, addGUIItem(Material.DIAMOND_BOOTS, "§6Tod bei Sprinten", "§cSpieler Stirbt beim Sprinten")); - SettingsGUI.setItem(19, addGUIItem(Material.LEATHER_BOOTS, "§6Tod bei Springen", "§cSpieler Stirbt beim Springen")); - SettingsGUI.setItem(20, addGUIItem(Material.BARRIER, "§6Inv Löschen bei DMG","§cLöscht das Inventar von allen wenn ein Spieler schaden bekommt!")); - - SettingsGUI.setItem(26, addGUIItem(Material.TNT, "§6Sterben durch TnT","§cTötet dich mit tnt bei der nicht Springen Schleichen und Jumpen Challenge")); - - SettingsGUI.setItem(36, addGUIItem(Material.CHEST, "§6KeepInventory", "§cStirbst du, beh§lst du dein Inventar")); - SettingsGUI.setItem(44, addGUIItem(Material.GOLDEN_APPLE, "§6Natürliche Regeneration", "§cSchalte natürliche Regeneration um")); - - SettingsGUI.setItem(9, addGUIItem(getDye("craftingtable"), getBool("craftingtable"))); - SettingsGUI.setItem(10, addGUIItem(getDye("allowtrading"), getBool("allowtrading"))); - SettingsGUI.setItem(11, addGUIItem(getDye("deathonfall"), getBool("deathonfall"))); - SettingsGUI.setItem(12, addGUIItem(getDye("damageonsneak"), getBool("damageonsneak"))); - SettingsGUI.setItem(13, addGUIItem(getDye("rnddrops"), getBool("rnddrops"))); - SettingsGUI.setItem(14, addGUIItem(getDye("sharedmg"), getBool("sharedmg"))); - SettingsGUI.setItem(15, addGUIItem(getDye("respawn"), getBool("respawn"))); - SettingsGUI.setItem(16, addGUIItem(getDye("onelife"), getBool("onelife"))); - SettingsGUI.setItem(17, addGUIItem(getDye("dmginchat"), getBool("dmginchat"))); - SettingsGUI.setItem(27, addGUIItem(getDye("deathonsprint"), getBool("deathonsprint"))); - SettingsGUI.setItem(28, addGUIItem(getDye("deathonjump"), getBool("deathonjump"))); - SettingsGUI.setItem(29, addGUIItem(getDye("clinvdmg"), getBool("clinvdmg"))); - - SettingsGUI.setItem(35, addGUIItem(getDye("tntdeath"), getBool("tntdeath"))); - - SettingsGUI.setItem(37, addGUIItem(getgrDye("keepInventory"), getgrBool("keepInventory"))); - SettingsGUI.setItem(43, addGUIItem(getgrDye("naturalRegeneration"), getgrBool("naturalRegeneration"))); - - - - for (int i = 0; i < 45; i++) { - if (SettingsGUI.getItem(i) == null) - SettingsGUI.setItem(i, addGUIItem(Material.GRAY_STAINED_GLASS_PANE, "")); - } - p.openInventory(SettingsGUI); - } - - private Material getDye(String cnfpath) { - ItemStack mat = new ItemStack(Material.GRAY_DYE); - if (getConfig().getBoolean(cnfpath) == true) { - mat.setType(Material.LIME_DYE); - } else { - mat.setType(Material.RED_DYE); - } - return mat.getType(); - } - - private String getBool(String cnfpath) { - if (getConfig().getBoolean(cnfpath) == true) - return "§aTrue"; - return "§cFalse"; - } - - - - @SuppressWarnings("deprecation") - private Material getgrDye(String gr) { - ItemStack mat = new ItemStack(Material.GRAY_DYE); - World wld = Bukkit.getWorlds().get(0); - if (wld.getGameRuleValue(gr).equals("true")) { - mat.setType(Material.LIME_DYE); - } else if (wld.getGameRuleValue(gr).equals("false")) { - mat.setType(Material.RED_DYE); - } - return mat.getType(); - } - - - - @SuppressWarnings("deprecation") -private String getgrBool(String gr) { - World wld = Bukkit.getWorlds().get(0); - if (wld.getGameRuleValue(gr).equals("true")) - return "§aTrue"; - if (wld.getGameRuleValue(gr).equals("false")) - return "§cFalse"; - return "§7Unknown"; - } - - - - private ItemStack addGUIItem(Material mat, String name, String... lore) { - ItemStack item = new ItemStack(mat, 1); - ItemMeta meta = item.getItemMeta(); - meta.setDisplayName(name); - ArrayList metalore = new ArrayList<>(); - if (lore != null) - for (String lorecomments : lore) - metalore.add(lorecomments); - meta.setLore(metalore); - item.setItemMeta(meta); - return item; - } - - public SBManager getSBManager() { - return this.sbManager; - } -} diff --git a/src/main/java/net/brennholz/challenges/RandomDrops.java b/src/main/java/net/brennholz/challenges/RandomDrops.java deleted file mode 100644 index e45f406..0000000 --- a/src/main/java/net/brennholz/challenges/RandomDrops.java +++ /dev/null @@ -1,59 +0,0 @@ -package net.brennholz.challenges; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.Random; -import java.util.stream.Collectors; -import org.bukkit.Material; -import org.bukkit.block.Block; -import org.bukkit.configuration.file.FileConfiguration; - -public class RandomDrops { - private final ArrayList BLOCKS; - - private final ArrayList ITEM_DROPS; - - private HashMap drops = new HashMap<>(); - - public RandomDrops() { - this.BLOCKS = (ArrayList)Arrays.stream(Material.values()).filter(mat -> mat.isBlock()).collect(Collectors.toList()); - this.ITEM_DROPS = (ArrayList)Arrays.stream(Material.values()).filter(mat -> (mat.isItem() || mat == Material.BEDROCK)).collect(Collectors.toList()); - } - - public void shuffleItems() { - Collections.shuffle(this.ITEM_DROPS); - ArrayList itemDropsCopy = new ArrayList<>(); - this.ITEM_DROPS.forEach(m -> itemDropsCopy.add(m)); - this.BLOCKS.forEach(mat -> { - int r = (new Random()).nextInt(itemDropsCopy.size() - 1); - this.drops.put(mat, itemDropsCopy.get(r)); - itemDropsCopy.remove(r); - }); - saveItems(); - } - - public void saveItems() { - FileConfiguration config = Challenges.getplugin().getRndDropsConfig(); - config.set("drops", this.drops.entrySet().stream().map(entry -> (new StringBuilder()).append(entry.getKey()).append(":").append(entry.getValue()).toString()).collect(Collectors.toList())); - } - - public void loadItems() { - this.drops.clear(); - FileConfiguration config = Challenges.getplugin().getRndDropsConfig(); - if (config.isList("drops")) { - config.getStringList("drops").forEach(str -> { - String[] materialSplitted = str.split(":"); - this.drops.put(Material.getMaterial(materialSplitted[0]), Material.getMaterial(materialSplitted[1])); - }); - } else { - shuffleItems(); - } - } - - public Material getMaterialFromBlock(Block block) { - return this.drops.get(block.getType()); - } -} - diff --git a/src/main/java/net/brennholz/challenges/SBManager.java b/src/main/java/net/brennholz/challenges/SBManager.java deleted file mode 100644 index 923f327..0000000 --- a/src/main/java/net/brennholz/challenges/SBManager.java +++ /dev/null @@ -1,22 +0,0 @@ -package net.brennholz.challenges; - -import org.bukkit.Bukkit; -import org.bukkit.entity.Player; -import org.bukkit.scoreboard.DisplaySlot; -import org.bukkit.scoreboard.Objective; -import org.bukkit.scoreboard.RenderType; -import org.bukkit.scoreboard.Scoreboard; -import org.bukkit.scoreboard.ScoreboardManager; - -public class SBManager { - public void createScoreboard(Player p) { - ScoreboardManager manager = Bukkit.getScoreboardManager(); - Scoreboard sb = manager.getNewScoreboard(); - @SuppressWarnings("deprecation") - Objective TabHP = sb.registerNewObjective("§6Challenges", "health"); - TabHP.setDisplaySlot(DisplaySlot.PLAYER_LIST); - TabHP.setDisplayName("§cHP"); - TabHP.setRenderType(RenderType.HEARTS); - p.setScoreboard(sb); - } -} diff --git a/src/main/java/net/brennholz/commands/Challenges_Command.java b/src/main/java/net/brennholz/commands/Challenges_Command.java deleted file mode 100644 index 9b3f5a8..0000000 --- a/src/main/java/net/brennholz/commands/Challenges_Command.java +++ /dev/null @@ -1,27 +0,0 @@ -package net.brennholz.commands; - - - -import org.bukkit.command.Command; -import org.bukkit.command.CommandExecutor; -import org.bukkit.command.CommandSender; - -public class Challenges_Command implements CommandExecutor { - - @Override - public boolean onCommand(CommandSender sender, Command cmd, String lable, String[] args) { - if (sender.hasPermission("challenges.challenges")) { - sender.sendMessage("§6Challenges Ver 1.9 by Brennholz3000"); - sender.sendMessage("§6Verfügbare Befehle:"); - sender.sendMessage("§c/HP §4- §6Verwalte die HP einzelner Spieler"); - sender.sendMessage("§c/Coords §4- §6Teile oder speichere Coordinaten"); - sender.sendMessage("§c/Settings §4- §6Verwalte die Challenges Einstellungen"); - sender.sendMessage("§c/Timer §4- §6Verwalte den Timer"); - sender.sendMessage("§c/Revive §4- §6Wiederbelebe Spieler"); - sender.sendMessage("§c/Backpack §6| §c/bp §4- §6öffne das Backpack"); - sender.sendMessage("§c/Reset §4- §6Generiert eine neue Welt, setzt den Timer zurück und löscht gespeicherte Positionen"); - } else - sender.sendMessage("§cDu hast hierfür keine Berechtigung"); - return true; - } -} diff --git a/src/main/java/net/brennholz/commands/Coords_Command.java b/src/main/java/net/brennholz/commands/Coords_Command.java deleted file mode 100644 index 0d216f0..0000000 --- a/src/main/java/net/brennholz/commands/Coords_Command.java +++ /dev/null @@ -1,159 +0,0 @@ -package net.brennholz.commands; - - - -import java.util.ArrayList; - -import org.bukkit.Bukkit; -import org.bukkit.Material; -import org.bukkit.command.Command; -import org.bukkit.command.CommandExecutor; -import org.bukkit.command.CommandSender; -import org.bukkit.entity.Player; -import org.bukkit.inventory.Inventory; -import org.bukkit.inventory.ItemStack; -import org.bukkit.inventory.meta.ItemMeta; - -import net.brennholz.challenges.Challenges; - -public class Coords_Command implements CommandExecutor { - - private Challenges chl = Challenges.getplugin(); - - public static Inventory CoordsGUI = Bukkit.createInventory(null, 45, "§6Koordinaten"); - public static Inventory CoordsDeleteGUI = Bukkit.createInventory(null, 9, "§6Entferne Koordinate"); - - public static String CGUIN = "§6Koordinaten"; - public static String CDGUIN = "§6Entferne Koordinate"; - - @Override - public boolean onCommand(CommandSender sender, Command cmd, String lable, String[] args) { - if (sender instanceof Player) { - Player p = (Player) sender; - if (args.length == 0) { - if (p.hasPermission("challenges.coords.view")) { - createMainGUI(p); - } else - p.sendMessage("§cDu hast hierfür keine Berechtigung"); - } else if (args.length == 1) { - if (args[0].equalsIgnoreCase("share")) { - if (p.hasPermission("challenges.coords.share")) { - chl.getServer().broadcastMessage("§c" + p.getName() + " §6ist bei §c" + p.getLocation().getBlockX() + " " + p.getLocation().getBlockY() + " " + p.getLocation().getBlockZ() + " §6in Welt §6" + p.getWorld().getName()); - } else - p.sendMessage("§cDu hast hierfür keine Berechtigung"); - } else if (args[0].equalsIgnoreCase("get")) { - if (p.hasPermission("challenges.coords.get")) { - p.sendMessage("§6Verfügbare Positionen:"); - for (String key : chl.getConfig().getConfigurationSection("Saved_Locations").getKeys(false)) { - p.sendMessage("§c" + key); - } - } else - p.sendMessage("§cDu hast hierfür keine Berechtigung"); - } else - p.sendMessage("§cBenutze: /coords share/save/get/delete [Name]"); - } else if (args.length >= 2) { - if (args[0].equalsIgnoreCase("save")) { - if (p.hasPermission("challenges.coords.save")) { - if (!chl.getConfig().contains("Saved_Locations." + args[1])) { - chl.getServer().broadcastMessage("§7| §aPosition §8>> §2" + p.getName() + " §7- " + args[1] + " §7[§2" + p.getLocation().getBlockX() + "§7/§2" + p.getLocation().getBlockY() + "§7/§2" + p.getLocation().getBlockZ() + "§7]"); - chl.getConfig().set("Saved_Locations." + args[1] + ".World", p.getWorld().getName()); - chl.getConfig().set("Saved_Locations." + args[1] + ".BlockX", p.getLocation().getBlockX()); - chl.getConfig().set("Saved_Locations." + args[1] + ".BlockY", p.getLocation().getBlockY()); - chl.getConfig().set("Saved_Locations." + args[1] + ".BlockZ", p.getLocation().getBlockZ()); - chl.saveConfig(); - } else - p.sendMessage("§cDiese Position existiert bereits! Benutze einen anderen Namen oder lösche die alte zuerst mit /coords delete " + args[1]); - } else - p.sendMessage("§cDu hast hierfür keine Berechtigung"); - } else if (args[0].equalsIgnoreCase("get")) { - if (p.hasPermission("challenges.coords.get")) { - if (chl.getConfig().contains("Saved_Locations." + args[1])) { - String w = chl.getConfig().getString("Saved_Locations." + args[1] + ".World"); - String x = chl.getConfig().getString("Saved_Locations." + args[1] + ".BlockX"); - String y = chl.getConfig().getString("Saved_Locations." + args[1] + ".BlockY"); - String z = chl.getConfig().getString("Saved_Locations." + args[1] + ".BlockZ"); - p.sendMessage("§7| §aPosition §8>> §2" + p.getName() + " §7- " + args[1] + " §7[§2" + x + "§7/§2" + y + "§7/§2" + z + " " + w + "§7]"); - } else - p.sendMessage("§cDiese Position existiert nicht!"); - } else - p.sendMessage("§cDu hast hierfür keine Berechtigung"); - } else if (args[0].equalsIgnoreCase("delete")) { - if (p.hasPermission("challenges.coords.delete")) { - if (chl.getConfig().contains("Saved_Locations." + args[1])) { - createDeleteGUI(p, args[1]); - p.openInventory(CoordsDeleteGUI); - } else - p.sendMessage("§cDiese Position existiert nicht!"); - } else - p.sendMessage("§cDu hast hierfür keine Berechtigung"); - } else - p.sendMessage("§cBenutze: /coords share/save/get/delete [Name]"); - } - } else - sender.sendMessage("§cKein Konsolenbefehl!"); - return true; - } - - public void createMainGUI(Player p) { - int i = 0; - String w; - String x; - String y; - String z; - for (String key : chl.getConfig().getConfigurationSection("Saved_Locations").getKeys(false)) { - if (i >= 45) { - break; - } - w = chl.getConfig().getString("Saved_Locations." + key + ".World"); - x = chl.getConfig().getString("Saved_Locations." + key + ".BlockX"); - y = chl.getConfig().getString("Saved_Locations." + key + ".BlockY"); - z = chl.getConfig().getString("Saved_Locations." + key + ".BlockZ"); - CoordsGUI.setItem(i, addGUIItem(getBlock(w), key, "§bX: §c" + x, "§bY: §c" + y, "§bZ: §c" + z)); - i++; - } - for (int ii = i; ii < 45; ii++) { - CoordsGUI.setItem(ii, addGUIItem(Material.AIR, "")); - } - p.openInventory(CoordsGUI); - } - - public void createDeleteGUI(Player p, String dname) { - CoordsDeleteGUI.setItem(0, addGUIItem(Material.LIME_TERRACOTTA, "§aLöschen bestätigen", "§bWegpunkt: §c" + dname)); - CoordsDeleteGUI.setItem(4, addGUIItem(Material.ORANGE_BANNER, dname)); - for (int i = 1; i < 8; i++) { - if (CoordsDeleteGUI.getItem(i) == null) { - CoordsDeleteGUI.setItem(i, addGUIItem(Material.ORANGE_STAINED_GLASS_PANE, "")); - } - } - CoordsDeleteGUI.setItem(8, addGUIItem(Material.RED_TERRACOTTA, "§cLöschen abbrechen", "§bWegpunkt: §c" + dname)); - p.openInventory(CoordsDeleteGUI); - } - - private ItemStack addGUIItem(Material mat, String name, String... lore) { - ItemStack item = new ItemStack(mat, 1); - ItemMeta meta = item.getItemMeta(); - if (mat != Material.AIR) { - meta.setDisplayName(name); - ArrayList metalore = new ArrayList(); - if (lore != null) { - for (String lorecomments : lore) { - metalore.add(lorecomments); - } - } - meta.setLore(metalore); - item.setItemMeta(meta); - } - return item; - } - - private Material getBlock(String wname) { - ItemStack mat = new ItemStack(Material.GRASS_BLOCK); - if (wname.equals(Bukkit.getWorlds().get(1).getName())) { - mat.setType(Material.NETHERRACK); - } else if (wname.equals(Bukkit.getWorlds().get(2).getName())) { - mat.setType(Material.END_STONE); - } - return mat.getType(); - } - -} \ No newline at end of file diff --git a/src/main/java/net/brennholz/commands/HP_Command.java b/src/main/java/net/brennholz/commands/HP_Command.java deleted file mode 100644 index 8fde042..0000000 --- a/src/main/java/net/brennholz/commands/HP_Command.java +++ /dev/null @@ -1,97 +0,0 @@ -package net.brennholz.commands; - - - -import org.bukkit.Bukkit; -import org.bukkit.OfflinePlayer; -import org.bukkit.command.Command; -import org.bukkit.command.CommandExecutor; -import org.bukkit.command.CommandSender; -import org.bukkit.entity.Player; - -public class HP_Command implements CommandExecutor { - - @SuppressWarnings("deprecation") - @Override - public boolean onCommand(CommandSender sender, Command cmd, String lable, String[] args) { - if (sender.hasPermission("challenges.hp.modify")) { - if (args.length >= 2) { - if (args[0].equalsIgnoreCase("max")) { - if (Double.parseDouble(args[1]) > 0) { - for (Player pp : Bukkit.getOnlinePlayers()) { - pp.setMaxHealth(Double.parseDouble(args[1])); - pp.setHealth(pp.getMaxHealth()); - } - sender.sendMessage("§6Du hast die maximalen HP auf §c" + args[1] + " §6gesetzt!"); - } - } else if (args[0].equalsIgnoreCase("get")) { - OfflinePlayer other = (Bukkit.getServer().getOfflinePlayer(args[1])); - if (other.isOnline()) { - Player p = (Player) other; - sender.sendMessage("§6" + p.getName() + " §ebesitzt derzeit §6" + p.getHealth() + "HP§e!"); - } else - sender.sendMessage("§cDieser Spieler ist nicht online!"); - } else if (args.length >= 3) { - OfflinePlayer other = (Bukkit.getServer().getOfflinePlayer(args[1])); - if (other.isOnline()) { - Player p = (Player) other; - double finaladdhp = p.getHealth() + Double.parseDouble(args[2]); - double finalremhp = p.getHealth() - Double.parseDouble(args[2]); - if (args[0].equalsIgnoreCase("add")) { - if (!(finaladdhp > p.getMaxHealth()) && !(finaladdhp < 0)) { - p.setHealth(finaladdhp); - p.sendMessage("§aDu wurdest von §b" + sender.getName() + " §aum §c" + args[2] - + "HP §ageheilt!"); - sender.sendMessage( - "§aDu hast §b" + p.getName() + " §aum §c" + args[2] + "HP §ageheilt!"); - } else - sender.sendMessage("§cUnm§gliche Operation"); - } - if (args[0].equalsIgnoreCase("remove")) { - if (!(finalremhp > p.getMaxHealth()) && !(finalremhp < 0)) { - p.setHealth(finalremhp); - p.sendMessage("§4" + sender.getName() + " §chat dir §4" + args[2] + "HP §centfernt!"); - sender.sendMessage("§cDu hast §4" + p.getName() + " " + args[2] + "HP §centfernt!"); - } else - sender.sendMessage("§cUnmögliche Operation!"); - } - if (args[0].equalsIgnoreCase("set")) { - if (!(Double.parseDouble(args[2]) > p.getMaxHealth()) - && !(Double.parseDouble(args[2]) < 0)) { - p.setHealth(Double.parseDouble(args[2])); - p.sendMessage( - "§6" + sender.getName() + " §ehat deine HP auf §6" + args[2] + " §egesetzt!"); - sender.sendMessage("§eDu hast die HP von §6" + p.getName() + " §eauf §6" + args[2] - + " §egesetzt!"); - } else - sender.sendMessage("§cUnmögliche Operation"); - } - } else - sender.sendMessage("§cDieser Spieler ist nicht online!"); - } else { - sender.sendMessage("§c~~~~~ §6HP command §c~~~~~"); - sender.sendMessage("§c/HP Get §4- §6Erhalte die aktuelen HP eines Spielers"); - sender.sendMessage( - "§c/HP Add §4- §6Füge einem Spieler die angegebene Zahl an Herzen hinzu"); - sender.sendMessage( - "§c/HP Remove §4- §6Entferne einem Spieler die angegebene Zahl an Herzen"); - sender.sendMessage( - "§c/HP Set §4- §6Setze die Herzen eines Spieler auf die angegebene Zahl"); - sender.sendMessage("§c/HP Max §4- §6Setze die maximalen HP aller Spieler"); - } - } else { - sender.sendMessage("§c~~~~~ §6HP command §c~~~~~"); - sender.sendMessage("§c/HP Get §4- §6Erhalte die aktuelen HP eines Spielers"); - sender.sendMessage( - "§c/HP Add §4- §6Füge einem Spieler die angegebene Zahl an Herzen hinzu"); - sender.sendMessage( - "§c/HP Remove §4- §6Entferne einem Spieler die angegebene Zahl an Herzen"); - sender.sendMessage( - "§c/HP Set §4- §6Setze die Herzen eines Spieler auf die angegebene Zahl"); - sender.sendMessage("§c/HP Max §4- §6Setze die maximalen HP aller Spieler"); - } - } else - sender.sendMessage("§cDu hast hierfür keine Berechtigung"); - return true; - } -} diff --git a/src/main/java/net/brennholz/commands/Reset_Command.java b/src/main/java/net/brennholz/commands/Reset_Command.java deleted file mode 100644 index 85a008c..0000000 --- a/src/main/java/net/brennholz/commands/Reset_Command.java +++ /dev/null @@ -1,54 +0,0 @@ -package net.brennholz.commands; - - - -import org.bukkit.Bukkit; -import org.bukkit.command.Command; -import org.bukkit.command.CommandExecutor; -import org.bukkit.command.CommandSender; -import org.bukkit.command.ConsoleCommandSender; -import org.bukkit.entity.Player; - -import net.brennholz.challenges.Backpack; -import net.brennholz.challenges.Challenges; - -public class Reset_Command implements CommandExecutor { - - private Challenges chl = Challenges.getplugin(); - Backpack backpack; - - @Override - public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) { - { - - } - Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lb clearlog all world world"); - Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lb clearlog all world world_nether"); - Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lb clearlog all world world_the_end"); - - chl.getConfig().set("World_Name", Bukkit.getWorlds().get(0).getName()); - chl.getConfig().set("World_Reset", true); - chl.getConfig().set("timer.enabled", false); - chl.getConfig().set("timer.time", 0); - chl.getConfig().set("timer.sek", "00"); - chl.getConfig().set("timer.min", "00"); - chl.getConfig().set("timer.hrs", 0); - for (String key : chl.getConfig().getConfigurationSection("Saved_Locations").getKeys(false)) { - chl.getConfig().set("Saved_Locations." + key, null); - } - chl.saveConfig(); - - Bukkit.getScheduler().scheduleSyncDelayedTask(chl, new Runnable() { - @Override - public void run() { - for (Player p : Bukkit.getOnlinePlayers()) { - p.sendTitle("§aWelt wird zurückgesetzt!", "§cBitte warte einen Moment§a.§b.§e.", 10, 400, 10); - p.kickPlayer("§cWelt wird zurückgesetzt!\n§cBitte warte einen Moment..."); - } - ConsoleCommandSender console = Bukkit.getServer().getConsoleSender(); - Bukkit.dispatchCommand(console, "restart"); - } - }, 60); - return true; - } -} diff --git a/src/main/java/net/brennholz/commands/Revive_Command.java b/src/main/java/net/brennholz/commands/Revive_Command.java deleted file mode 100644 index d47fc30..0000000 --- a/src/main/java/net/brennholz/commands/Revive_Command.java +++ /dev/null @@ -1,75 +0,0 @@ -package net.brennholz.commands; - - - -import org.bukkit.Bukkit; -import org.bukkit.GameMode; -import org.bukkit.Location; -import org.bukkit.OfflinePlayer; -import org.bukkit.World; -import org.bukkit.command.Command; -import org.bukkit.command.CommandExecutor; -import org.bukkit.command.CommandSender; -import org.bukkit.entity.Player; - -import net.brennholz.challenges.Challenges; - -public class Revive_Command implements CommandExecutor { - - private Challenges chl = Challenges.getplugin(); - - @SuppressWarnings("deprecation") - @Override - public boolean onCommand(CommandSender sender, Command cmd, String lable, String[] args) { - if (sender.hasPermission("challenges.revive")) { - if (args.length == 1) { - if (args[0].equalsIgnoreCase("all")) { - for (Player p : Bukkit.getOnlinePlayers()) { - p.setHealth(p.getMaxHealth()); - p.setGameMode(GameMode.SURVIVAL); - } - chl.getServer().broadcastMessage("§bAlle Spieler wurden wiederbelebt! §aEs kann weiter gehen!"); - } else { - OfflinePlayer other = (Bukkit.getServer().getOfflinePlayer(args[0])); - if (other.isOnline()) { - Player p = (Player) other; - p.setHealth(p.getMaxHealth()); - p.setGameMode(GameMode.SURVIVAL); - chl.getServer().broadcastMessage( - "§b" + p.getName() + " §awurde von §b" + sender.getName() + " §awiederbelebt!"); - } else - sender.sendMessage("§cDieser Spieler ist nicht online!"); - } - } else if (args.length >= 4) { - World w = Bukkit.getWorld(args[1]); - double x = Double.parseDouble(args[2]); - double y = Double.parseDouble(args[3]); - double z = Double.parseDouble(args[4]); - Location loc = new Location(w, x, y, z); - if (args[0].equalsIgnoreCase("all")) { - for (Player p : Bukkit.getOnlinePlayers()) { - p.teleport(loc); - p.setHealth(p.getMaxHealth()); - p.setGameMode(GameMode.SURVIVAL); - } - chl.getServer().broadcastMessage("§bAlle Spieler wurden bei §c" + w.getName() + " " + x + " " + y - + " " + z + " §bwiederbelebt! §aEs kann weiter gehen!"); - } else { - OfflinePlayer other = (Bukkit.getServer().getOfflinePlayer(args[0])); - if (other.isOnline()) { - Player p = (Player) other; - p.teleport(loc); - p.setHealth(p.getMaxHealth()); - p.setGameMode(GameMode.SURVIVAL); - chl.getServer().broadcastMessage("§b" + p.getName() + " §awurde von §b" + sender.getName() - + " §abei §c" + w.getName() + " " + x + " " + y + " " + z + " §awiederbelebt!"); - } else - sender.sendMessage("§cDieser Spieler ist nicht online!"); - } - } else - sender.sendMessage("§cBenutze: /revive [world] [x] [y] [z]"); - } else - sender.sendMessage("§cDu hast hierfür keine Berechtigung"); - return true; - } -} diff --git a/src/main/java/net/brennholz/commands/Settings_Command.java b/src/main/java/net/brennholz/commands/Settings_Command.java deleted file mode 100644 index c4d308c..0000000 --- a/src/main/java/net/brennholz/commands/Settings_Command.java +++ /dev/null @@ -1,103 +0,0 @@ -package net.brennholz.commands; - -import org.bukkit.command.Command; -import org.bukkit.command.CommandExecutor; -import org.bukkit.command.CommandSender; -import org.bukkit.entity.Player; - -import net.brennholz.challenges.Challenges; - -public class Settings_Command implements CommandExecutor { - - private Challenges chl = Challenges.getplugin(); - - @Override - public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) { - if (sender instanceof Player) { - Player p = (Player) sender; - if (args.length == 0) { - if (p.hasPermission("challenges.settings.view")) { - chl.createGUI(p); - } else { - p.sendMessage("hast hierfkeine Berechtigung"); - } - } else if (args.length == 1) { - if (args[0].equalsIgnoreCase("get")) { - if (p.hasPermission("challenges.settings.get")) { - p.sendMessage("Einstellungen"); - p.sendMessage("Crafting =" + chl.getConfig().getBoolean("craftingtable")); - p.sendMessage("Handeln =" + chl.getConfig().getBoolean("allowtrading")); - p.sendMessage("bei Fallschaden =" + chl.getConfig().getBoolean("deathonfall")); - p.sendMessage("bei Schleichen =" + chl.getConfig().getBoolean("damageonsneak")); - p.sendMessage("Schaden bei Schleichen =" + chl.getConfig().getInt("sneakdmg")); - p.sendMessage("Drops =" + chl.getConfig().getBoolean("rnddrops")); - p.sendMessage("Schaden =" + chl.getConfig().getBoolean("sharedmg")); - p.sendMessage("Leben falle =" + chl.getConfig().getBoolean("onelife")); - p.sendMessage("in Chat =" + chl.getConfig().getBoolean("dmginchat")); - p.sendMessage("=" + chl.getConfig().getBoolean("respawn")); - } else { - p.sendMessage("hast hierfkeine Berechtigung"); - } - } else { - p.sendMessage("/settings Get/Crafting/Trading/DeathFall/DMGOnSneak/SneakDMG/RndDrops/ShareDMG/Respawn/OneLife/ChatDMG [True/False]"); - } - } else if (args.length >= 2) { - if (p.hasPermission("challenges.settings.modify")) { - Boolean Bwert = Boolean.valueOf(Boolean.parseBoolean(args[1])); - if (args[0].equalsIgnoreCase("crafting")) { - chl.getConfig().set("craftingtable", Bwert); - chl.saveConfig(); - p.sendMessage("Crafting =" + chl.getConfig().getBoolean("craftingtable")); - } else if (args[0].equalsIgnoreCase("deathfall")) { - chl.getConfig().set("deathonfall", Bwert); - chl.saveConfig(); - p.sendMessage("bei Fallschaden =" + chl.getConfig().getBoolean("deathonfall")); - } else if (args[0].equalsIgnoreCase("trading")) { - chl.getConfig().set("allowtrading", Bwert); - chl.saveConfig(); - p.sendMessage("Handeln =" + chl.getConfig().getBoolean("allowtrading")); - } else if (args[0].equalsIgnoreCase("dmgonsneak")) { - chl.getConfig().set("damageonsneak", Bwert); - chl.saveConfig(); - p.sendMessage("bei Schleichen =" + chl.getConfig().getBoolean("damageonsneak")); - } else if (args[0].equalsIgnoreCase("sneakdmg")) { - Double Dwert = Double.valueOf(Double.parseDouble(args[1])); - chl.getConfig().set("sneakdmg", Dwert); - chl.saveConfig(); - p.sendMessage("Schaden bei Schleichen =" + chl.getConfig().getString("sneakdmg")); - } else if (args[0].equalsIgnoreCase("rnddrops")) { - chl.getConfig().set("rnddrops", Bwert); - chl.saveConfig(); - p.sendMessage("Drops =" + chl.getConfig().getBoolean("rnddrops")); - } else if (args[0].equalsIgnoreCase("sharedmg")) { - chl.getConfig().set("sharehp", Bwert); - chl.saveConfig(); - p.sendMessage("Schaden =" + chl.getConfig().getBoolean("sharedmg")); - } else if (args[0].equalsIgnoreCase("respawn")) { - chl.getConfig().set("respawn", Bwert); - chl.saveConfig(); - p.sendMessage("=" + chl.getConfig().getBoolean("respawn")); - } else if (args[0].equalsIgnoreCase("onelife")) { - chl.getConfig().set("onelife", Bwert); - chl.saveConfig(); - p.sendMessage("Leben falle =" + chl.getConfig().getBoolean("onelife")); - } else if (args[0].equalsIgnoreCase("chatdmg")) { - chl.getConfig().set("dmginchat", Bwert); - chl.saveConfig(); - p.sendMessage("in Chat =" + chl.getConfig().getBoolean("dmginchat")); - } else { - p.sendMessage("Parameter!"); - } - } else { - p.sendMessage("hast hierfkeine Berechtigung"); - } - } else { - p.sendMessage( - "/settings Get/Crafting/Trading/DeathFall/DMGOnSneak/SneakDMG/RndDrops/ShareDMG/Respawn/OneLife/ChatDMG [True/False]"); - } - } else { - sender.sendMessage("Konsolenbefehl!"); - } - return true; - } -} diff --git a/src/main/java/net/brennholz/commands/Timer_Command.java b/src/main/java/net/brennholz/commands/Timer_Command.java deleted file mode 100644 index 870fde9..0000000 --- a/src/main/java/net/brennholz/commands/Timer_Command.java +++ /dev/null @@ -1,125 +0,0 @@ -package net.brennholz.commands; - - - -import net.brennholz.challenges.Challenges; -import org.bukkit.Bukkit; -import org.bukkit.command.Command; -import org.bukkit.command.CommandExecutor; -import org.bukkit.command.CommandSender; -import org.bukkit.entity.Player; - -public class Timer_Command implements CommandExecutor { - - private Challenges chl = Challenges.getplugin(); - public boolean timer; - private int zeit = chl.getConfig().getInt("timer.time"); - private int sek; - private int min; - private int hrs; - private String ssek; - private String smin; - - @Override - public boolean onCommand(CommandSender sender, Command cmd, String lable, String[] args) { - timer = chl.getConfig().getBoolean("timer.enabled"); - if (sender.hasPermission("challenges.timer")) { - if (args.length >= 1) { - if (args[0].equalsIgnoreCase("resume")) { - if (timer == false) { - timer = true; - chl.getServer().broadcastMessage("§aDer Timer wird fortgesetzt!"); - chl.getConfig().set("timer.enabled", timer); - chl.saveConfig(); - } else - sender.sendMessage("§cDer Timer läuft bereits!"); - } else if (args[0].equalsIgnoreCase("pause")) { - if (timer == true) { - timer = false; - chl.getServer().broadcastMessage("§6Der Timer wurde angehalten"); - chl.getConfig().set("timer.enabled", timer); - chl.saveConfig(); - } else - sender.sendMessage("§cDer Timer ist bereits pausiert!"); - } else if (args[0].equalsIgnoreCase("reset")) { - timer = false; - chl.getConfig().set("timer.enabled", timer); - chl.saveConfig(); - zeit = 0; - sek = 0; - min = 0; - hrs = 0; - RefreshConfig(); - chl.getServer().broadcastMessage("§cDer Timer wurde zurückgesetzt!"); - } else if (args.length >= 2) { - if (args[0].equalsIgnoreCase("set")) { - timer = false; - chl.getConfig().set("timer.enabled", timer); - chl.saveConfig(); - zeit = Integer.parseInt(args[1]); - RefreshConfig(); - chl.getServer().broadcastMessage( - "§bDer Timer wurde auf §a" + hrs + ":" + smin + ":" + ssek + " §bgesetzt!"); - } - } else - sender.sendMessage("§cBenutze: /timer resume/pause/reset/set [Zeit in Sekunden]"); - } else { - sender.sendMessage("§c~~~~~ §6Timer command §c~~~~~"); - sender.sendMessage("§c/timer resume §4- §6Setze den Timer fort"); - sender.sendMessage("§c/timer pause §4- §6Pausiere den Timer"); - sender.sendMessage("§c/timer reset §4- §6Setze den Timer zurück"); - sender.sendMessage("§c/timer set [Zeit in Sekunden] §4- §6Setze den Timer auf eine bestimmte Zeit"); - } - } else - sender.sendMessage("§cDu hast hierfür keine Berechtigung"); - return true; - - } - - @SuppressWarnings("deprecation") - public void Run_Timer() { - Bukkit.getScheduler().scheduleAsyncRepeatingTask(chl, new Runnable() { - @Override - public void run() { - boolean ttimer = chl.getConfig().getBoolean("timer.enabled"); - int ttime = chl.getConfig().getInt("timer.time"); - int thrs = chl.getConfig().getInt("timer.hrs"); - String tsek = chl.getConfig().getString("timer.sek"); - String tmin = chl.getConfig().getString("timer.min"); - if (ttimer) { - ttime = ttime + 1; - zeit = ttime; - RefreshConfig(); - for (Player p : chl.getServer().getOnlinePlayers()) { - p.sendActionBar("§7Challenge§8: §2§l" + thrs + ":" + tmin + ":" + tsek); - } - } else { - for (Player p : chl.getServer().getOnlinePlayers()) { - p.sendActionBar("§6Der Timer ist pausiert."); - } - } - } - }, 1 * 20L, 1 * 20L); - } - - public void RefreshConfig() { - min = zeit / 60; - hrs = min / 60; - min = min % 60; - sek = zeit % 60; - if (sek >= 10) { - ssek = Integer.toString(sek); - } else - ssek = '0' + Integer.toString(sek); - if (min >= 10) { - smin = Integer.toString(min); - } else - smin = '0' + Integer.toString(min); - chl.getConfig().set("timer.time", zeit); - chl.getConfig().set("timer.sek", ssek); - chl.getConfig().set("timer.min", smin); - chl.getConfig().set("timer.hrs", hrs); - chl.saveConfig(); - } - -} diff --git a/src/main/java/net/brennholz/events/BlockCreateListener.java b/src/main/java/net/brennholz/events/BlockCreateListener.java deleted file mode 100644 index dd4df6c..0000000 --- a/src/main/java/net/brennholz/events/BlockCreateListener.java +++ /dev/null @@ -1,29 +0,0 @@ -package net.brennholz.events; - - - -import org.bukkit.event.EventHandler; -import org.bukkit.event.Listener; -import org.bukkit.event.block.BlockPlaceEvent; -import org.bukkit.event.player.PlayerBucketEmptyEvent; - -import net.brennholz.challenges.Challenges; - -public class BlockCreateListener implements Listener { - - private Challenges chl = Challenges.getplugin(); - - @EventHandler - public void onBlockPlace(BlockPlaceEvent e) { - if (this.chl.getConfig().getBoolean("timer.enabled") == false) { - e.setCancelled(true); - } - } - - @EventHandler - public void onBucketPlace(PlayerBucketEmptyEvent e) { - if (this.chl.getConfig().getBoolean("timer.enabled") == false) { - e.setCancelled(true); - } - } -} diff --git a/src/main/java/net/brennholz/events/BlockDestroyListener.java b/src/main/java/net/brennholz/events/BlockDestroyListener.java deleted file mode 100644 index 7297dbc..0000000 --- a/src/main/java/net/brennholz/events/BlockDestroyListener.java +++ /dev/null @@ -1,57 +0,0 @@ -package net.brennholz.events; - - - -import org.bukkit.Material; -import org.bukkit.event.EventHandler; -import org.bukkit.event.Listener; -import org.bukkit.event.block.BlockBreakEvent; -import org.bukkit.event.block.BlockExplodeEvent; -import org.bukkit.event.entity.EntityExplodeEvent; -import org.bukkit.inventory.ItemStack; - -import net.brennholz.challenges.Challenges; - -public class BlockDestroyListener implements Listener { - - private Challenges chl = Challenges.getplugin(); - - @EventHandler - public void onBlockBreak(BlockBreakEvent e) { - if (this.chl.getConfig().getBoolean("rnddrops") == true && this.chl.getConfig().getBoolean("timer.enabled") == true) { - e.setDropItems(false); - e.getBlock().getWorld().dropItem(e.getBlock().getLocation().add(0.5D, 0.5D, 0.5D), new ItemStack(this.chl.getRandomDropsManager().getMaterialFromBlock(e.getBlock()))); - } - if (this.chl.getConfig().getBoolean("timer.enabled") == false) { - e.setCancelled(true); - } - } - - @EventHandler - public void onBlockExplode(BlockExplodeEvent e) { - if (this.chl.getConfig().getBoolean("rnddrops") == true) { - e.blockList().forEach(block -> { - if(!block.getType().isAir()){ - block.getWorld().dropItem(block.getLocation().add(0.5D, 0.5D, 0.5D),new ItemStack(this.chl.getRandomDropsManager().getMaterialFromBlock(block))); - block.setType(Material.AIR); - } - }); - e.blockList().clear(); - } - } - - @EventHandler - public void onEntityExplode(EntityExplodeEvent e) { - if (this.chl.getConfig().getBoolean("rnddrops") == true) { - e.blockList().forEach(block -> { - if(!block.getType().isAir()){ - block.getWorld().dropItem(block.getLocation().add(0.5D, 0.5D, 0.5D),new ItemStack(this.chl.getRandomDropsManager().getMaterialFromBlock(block))); - block.setType(Material.AIR); - } - }); - e.blockList().clear(); - } - } - -} - diff --git a/src/main/java/net/brennholz/events/DamageListener.java b/src/main/java/net/brennholz/events/DamageListener.java deleted file mode 100644 index e15b7b0..0000000 --- a/src/main/java/net/brennholz/events/DamageListener.java +++ /dev/null @@ -1,175 +0,0 @@ -package net.brennholz.events; - - - -import java.text.DecimalFormat; - - -import org.bukkit.Bukkit; -import org.bukkit.GameMode; -import org.bukkit.Location; -import org.bukkit.Sound; -import org.bukkit.entity.EntityType; -import org.bukkit.entity.Player; -import org.bukkit.entity.TNTPrimed; -import org.bukkit.event.EventHandler; -import org.bukkit.event.Listener; -import org.bukkit.event.entity.EntityDamageByEntityEvent; -import org.bukkit.event.entity.EntityDamageEvent; -import org.bukkit.event.entity.EntityDamageEvent.DamageCause; -import org.bukkit.event.player.PlayerToggleSneakEvent; -import org.bukkit.event.player.PlayerToggleSprintEvent; - -import com.destroystokyo.paper.event.player.PlayerJumpEvent; - -import net.brennholz.challenges.Challenges; - -public class DamageListener implements Listener { - - private Challenges chl = Challenges.getplugin(); - - @EventHandler - public void onDamage(EntityDamageEvent e) { - if (e.getEntity() instanceof Player) { - Player p = (Player) e.getEntity(); - String dmg = new DecimalFormat("#.##").format(e.getFinalDamage()); - if (e.getFinalDamage() > 0) { - if (e.getCause() == DamageCause.FALL) { - if (chl.getConfig().getBoolean("deathonfall") == true) { - if (chl.getConfig().getBoolean("dmginchat") == true) { - Bukkit.broadcastMessage("§6" + p.getName() + " §chat §4" + p.getHealth() + " §cHP Schaden genommen durch §4" + e.getCause()); - } - Bukkit.getScheduler().scheduleSyncDelayedTask(chl, new Runnable() { - @Override - public void run() { - p.setHealth(0); - } - }, 1); - } else if (chl.getConfig().getBoolean("dmginchat") == true) { - Bukkit.broadcastMessage("§6" + p.getName() + " §chat §4" + dmg + " §cHP Schaden genommen durch §4" + e.getCause()); - } - } else if (e.getCause() == DamageCause.CUSTOM) { - if (!p.isSneaking() && (chl.getConfig().getBoolean("dmginchat") == true)) { - Bukkit.broadcastMessage("§6" + p.getName() + " §chat §4" + chl.getConfig().getDouble("sneakdmg") + " §cHP Schaden genommen durch §4SNEAKING"); - } - } else if (e.getCause() == DamageCause.ENTITY_ATTACK || e.getCause() == DamageCause.ENTITY_EXPLOSION) { - - } else if (chl.getConfig().getBoolean("dmginchat") == true) { - Bukkit.broadcastMessage("§6" + p.getName() + " §chat §4" + dmg + " §cHP Schaden genommen durch §4" + e.getCause()); - } - if (chl.getConfig().getBoolean("sharedmg") == true) { - for (Player pp : Bukkit.getOnlinePlayers()) { - if (pp != p) { - double health = pp.getHealth() - e.getFinalDamage(); - if(health < 0) { - pp.setHealth(0); - }else { - pp.setHealth(health); - pp.getWorld().playSound(pp.getLocation(), Sound.ENTITY_PLAYER_HURT, (float) 1, 1); - } - - } - } - } - } - } - } - - @EventHandler - public void onEntityDamage(EntityDamageByEntityEvent e) { - if ((e.getEntity() instanceof Player) && (e.getFinalDamage() > 0)) { - Player p = (Player) e.getEntity(); - String dmg = new DecimalFormat("#.##").format(e.getFinalDamage()); - if ((e.getCause() == DamageCause.ENTITY_ATTACK || e.getCause() == DamageCause.ENTITY_EXPLOSION) && chl.getConfig().getBoolean("dmginchat") == true) { - Bukkit.broadcastMessage("§6" + p.getName() + " §chat §4" + dmg + " §cHP Schaden genommen durch §4" + e.getDamager().getName()); - } - } - } - - @SuppressWarnings("deprecation") - @EventHandler - public void PlayerSneak(PlayerToggleSneakEvent e) { - Player p = (Player) e.getPlayer(); - if (p.getGameMode() == GameMode.SURVIVAL) { - if (!p.isSneaking()) { - if (chl.getConfig().getBoolean("damageonsneak") == true) { - if (chl.getConfig().getBoolean("tntdeath") == true) { - for (Player pp : Bukkit.getOnlinePlayers()) { - pp.sendTitle("§c" + p.getDisplayName().toString() + " §ahat gesneakt!", "§b:>"); - EntityType tnt = EntityType.PRIMED_TNT; - Location loc = pp.getLocation(); - TNTPrimed PRIME_TNT = (TNTPrimed) pp.getWorld().spawnEntity(loc, tnt); - PRIME_TNT.setCustomName("§c§lNUKE"); - PRIME_TNT.setFuseTicks(15); - PRIME_TNT.setYield(120); - PRIME_TNT.setIsIncendiary(true); - } - } else { - p.damage(chl.getConfig().getDouble("sneakdmg")); - } - } - } - } -} - - @SuppressWarnings("deprecation") - @EventHandler - public void PlayerSprint(PlayerToggleSprintEvent e) { - Player p = (Player) e.getPlayer(); - if (p.getGameMode() == GameMode.SURVIVAL) { - if (!p.isSprinting()) { - if (chl.getConfig().getBoolean("deathonsprint") == true) { - if (chl.getConfig().getBoolean("tntdeath") == true) { - for (Player pp : Bukkit.getOnlinePlayers()) { - pp.sendTitle("§c" + p.getDisplayName().toString() + " §aist gesprintet!", "§b:>"); - EntityType tnt = EntityType.PRIMED_TNT; - Location loc = pp.getLocation(); - TNTPrimed PRIME_TNT = (TNTPrimed) pp.getWorld().spawnEntity(loc, tnt); - PRIME_TNT.setCustomName("§c§lNUKE"); - PRIME_TNT.setFuseTicks(15); - PRIME_TNT.setYield(120); - PRIME_TNT.setIsIncendiary(true); - } - } else { - p.setHealth(0); - } - } - } - } - } - @SuppressWarnings("deprecation") - @EventHandler - public void PlayerJump(PlayerJumpEvent e) { - Player p = (Player) e.getPlayer(); - if (p.getGameMode() == GameMode.SURVIVAL) { - if (chl.getConfig().getBoolean("deathonjump") == true) { - if (chl.getConfig().getBoolean("tntdeath") == true) { - for (Player pp : Bukkit.getOnlinePlayers()) { - pp.sendTitle("§c" + p.getDisplayName().toString() + " §aist gesprungen!", "§b:>"); - EntityType tnt = EntityType.PRIMED_TNT; - Location loc = pp.getLocation(); - TNTPrimed PRIME_TNT = (TNTPrimed) pp.getWorld().spawnEntity(loc, tnt); - PRIME_TNT.setCustomName("§c§lNUKE"); - PRIME_TNT.setFuseTicks(15); - PRIME_TNT.setYield(120); - PRIME_TNT.setIsIncendiary(true); - } - } else { - p.setHealth(0); - } - } - } - } - @EventHandler - public void onDamageclear(EntityDamageEvent e) { - if (e.getEntity() instanceof Player) { - if (chl.getConfig().getBoolean("clinvdmg") == true) { - for (Player pp : Bukkit.getOnlinePlayers()) { - pp.getInventory().clear(); - - } - } - } - } -} - diff --git a/src/main/java/net/brennholz/events/DeathListener.java b/src/main/java/net/brennholz/events/DeathListener.java deleted file mode 100644 index 9534e79..0000000 --- a/src/main/java/net/brennholz/events/DeathListener.java +++ /dev/null @@ -1,74 +0,0 @@ -package net.brennholz.events; - - - -import org.bukkit.Bukkit; -import org.bukkit.GameMode; -import org.bukkit.entity.EnderDragon; -import org.bukkit.entity.Player; -import org.bukkit.event.EventHandler; -import org.bukkit.event.Listener; -import org.bukkit.event.entity.EntityDeathEvent; -import org.bukkit.event.entity.PlayerDeathEvent; -import org.bukkit.event.player.PlayerRespawnEvent; - -import net.brennholz.challenges.Challenges; - -public class DeathListener implements Listener { - - private Challenges chl = Challenges.getplugin(); - - @EventHandler - public void onPlayerDeath(PlayerDeathEvent e) { - if (chl.getConfig().getBoolean("onelife") == true) { - chl.getConfig().set("timer.enabled", false); - chl.saveConfig(); - for (Player p : Bukkit.getOnlinePlayers()) { - p.setGameMode(GameMode.SPECTATOR); - } - chl.getServer().broadcastMessage(""); - chl.getServer().broadcastMessage(""); - e.setDeathMessage("§6" + e.getEntity().getName() + " §cist gestorben!"); - chl.getServer().broadcastMessage("§cDie Challenge wurde nach §6" + chl.getConfig().getInt("timer.hrs") + ":" + chl.getConfig().getString("timer.min") + ":" + chl.getConfig().getString("timer.sek") + " §cabgebrochen!"); - chl.getServer().broadcastMessage("§aSeed: §b" + Bukkit.getWorlds().get(0).getSeed()); - chl.getServer().broadcastMessage("§6Um alle wiederzubeleben benutze §c/revive ALL"); - } else { - e.setDeathMessage("§6" + e.getEntity().getName() + " §cist gestorben! §6(" + e.getEntity().getWorld().getName() + " " + e.getEntity().getLocation().getBlockX() + " " + e.getEntity().getLocation().getBlockY() + " " + e.getEntity().getLocation().getBlockZ() + "§c)"); - if (chl.getConfig().getBoolean("respawn") == false) { - Bukkit.getServer().broadcastMessage("§6Benutze §c/revive " + e.getEntity().getName() + " [world] [x] [y] [z] §6um ihn wiederzubeleben!"); - } - } - } - - @EventHandler - public void onPlayerRespawn(PlayerRespawnEvent e) { - if (chl.getConfig().getBoolean("respawn") == false) { - e.getPlayer().sendTitle("§cDu bist gestorben!", "§4Du bist nun Zuschauer", 10, 80, 10); - Bukkit.getScheduler().scheduleSyncDelayedTask(chl, new Runnable() { - @Override - public void run() { - e.getPlayer().setGameMode(GameMode.SPECTATOR); - } - }, 1); - } - } - - @EventHandler - public void DragonDeath(EntityDeathEvent e) { - if (e.getEntity() instanceof EnderDragon) { - chl.getConfig().set("timer.enabled", false); - chl.getServer().broadcastMessage(""); - chl.getServer().broadcastMessage(""); - chl.getServer().broadcastMessage(""); - chl.getServer().broadcastMessage(""); - chl.getServer().broadcastMessage("§8>> §aDie Challenge wurde §2§lerfolgreich §aabgeschlossen."); - chl.getServer().broadcastMessage("§8>> §7Der §2§lEnderdrache §7ist gestorben."); - chl.getServer().broadcastMessage("§8>> §7Benötigte Zeit: §2§l" + chl.getConfig().getInt("timer.hrs") + ":"+ chl.getConfig().getString("timer.min") + ":" + chl.getConfig().getString("timer.sek") + "§7!"); - chl.getServer().broadcastMessage("§8>> §7Seed: §2§l" + Bukkit.getWorlds().get(0).getSeed()); - chl.getServer().broadcastMessage(""); - chl.getServer().broadcastMessage(""); - chl.getServer().broadcastMessage(""); - chl.getServer().broadcastMessage(""); - } - } -} diff --git a/src/main/java/net/brennholz/events/InteractListener.java b/src/main/java/net/brennholz/events/InteractListener.java deleted file mode 100644 index 265bb06..0000000 --- a/src/main/java/net/brennholz/events/InteractListener.java +++ /dev/null @@ -1,45 +0,0 @@ -package net.brennholz.events; - - - -import org.bukkit.Material; -import org.bukkit.entity.EntityType; -import org.bukkit.event.EventHandler; -import org.bukkit.event.Listener; -import org.bukkit.event.block.Action; -import org.bukkit.event.player.PlayerInteractEntityEvent; -import org.bukkit.event.player.PlayerInteractEvent; - -import net.brennholz.challenges.Challenges; - -public class InteractListener implements Listener { - - private Challenges chl = Challenges.getplugin(); - - @EventHandler - public void onBlockClick(PlayerInteractEvent e) { - if (e.getAction() == Action.RIGHT_CLICK_BLOCK) { - if (e.getClickedBlock().getType() == Material.CRAFTING_TABLE) { - if (chl.getConfig().getBoolean("craftingtable") == false) { - e.setCancelled(true); - } - } - if (this.chl.getConfig().getBoolean("timer.enabled") == false) { - e.setCancelled(true); - } - } - } - - @EventHandler - public void onEntityClick(PlayerInteractEntityEvent e) { - if (e.getRightClicked().getType() == EntityType.VILLAGER) { - if (chl.getConfig().getBoolean("allowtrading") == false) { - e.setCancelled(true); - } - } - if (this.chl.getConfig().getBoolean("timer.enabled") == false) { - e.setCancelled(true); - } - } -} - diff --git a/src/main/java/net/brennholz/events/InventoryClickListener.java b/src/main/java/net/brennholz/events/InventoryClickListener.java deleted file mode 100644 index ecba344..0000000 --- a/src/main/java/net/brennholz/events/InventoryClickListener.java +++ /dev/null @@ -1,124 +0,0 @@ -package net.brennholz.events; - - -import org.bukkit.Bukkit; -import org.bukkit.World; -import org.bukkit.entity.Player; -import org.bukkit.event.EventHandler; -import org.bukkit.event.Listener; -import org.bukkit.event.inventory.InventoryClickEvent; - -import net.brennholz.challenges.Challenges; - -public class InventoryClickListener implements Listener { - - private Challenges chl = Challenges.getplugin(); - - Challenges chall; - net.brennholz.commands.Coords_Command coco; - - @SuppressWarnings({ "deprecation", "static-access" }) - @EventHandler - public void InvClick(InventoryClickEvent e) { - World wld = Bukkit.getWorlds().get(0); - World nth = Bukkit.getWorlds().get(1); - World end = Bukkit.getWorlds().get(2); - String invname = e.getView().getTitle(); - Player p = (Player) e.getWhoClicked(); - int slot = e.getRawSlot(); - if (invname.equals(chall.GUIName)) { - e.setCancelled(true); - if (p.hasPermission("challenges.settings.modify")) { - switch (slot) { - case 9: - chl.getConfig().set("craftingtable", !(chl.getConfig().getBoolean("craftingtable"))); - break; - case 10: - chl.getConfig().set("allowtrading", !(chl.getConfig().getBoolean("allowtrading"))); - break; - case 11: - chl.getConfig().set("deathonfall", !(chl.getConfig().getBoolean("deathonfall"))); - break; - case 12: - chl.getConfig().set("damageonsneak", !(chl.getConfig().getBoolean("damageonsneak"))); - break; - case 13: - chl.getConfig().set("rnddrops", !(chl.getConfig().getBoolean("rnddrops"))); - break; - case 14: - chl.getConfig().set("sharedmg", !(chl.getConfig().getBoolean("sharedmg"))); - break; - case 15: - chl.getConfig().set("respawn", !(chl.getConfig().getBoolean("respawn"))); - break; - case 16: - chl.getConfig().set("onelife", !(chl.getConfig().getBoolean("onelife"))); - break; - case 17: - chl.getConfig().set("dmginchat", !(chl.getConfig().getBoolean("dmginchat"))); - break; - case 27: - chl.getConfig().set("deathonsprint", !(chl.getConfig().getBoolean("deathonsprint"))); - break; - case 28: - chl.getConfig().set("deathonjump", !(chl.getConfig().getBoolean("deathonjump"))); - break; - case 29: - chl.getConfig().set("clinvdmg", !(chl.getConfig().getBoolean("clinvdmg"))); - break; - case 35: - chl.getConfig().set("tntdeath", !(chl.getConfig().getBoolean("tntdeath"))); - break; - case 37: - if (wld.getGameRuleValue("keepInventory").equals("true")) { - wld.setGameRuleValue("keepInventory", "false"); - nth.setGameRuleValue("keepInventory", "false"); - end.setGameRuleValue("keepInventory", "false"); - } else if (wld.getGameRuleValue("keepInventory").equals("false")) { - wld.setGameRuleValue("keepInventory", "true"); - nth.setGameRuleValue("keepInventory", "true"); - end.setGameRuleValue("keepInventory", "true"); - } - break; - case 43: - if (wld.getGameRuleValue("naturalRegeneration").equals("true")) { - wld.setGameRuleValue("naturalRegeneration", "false"); - nth.setGameRuleValue("naturalRegeneration", "false"); - end.setGameRuleValue("naturalRegeneration", "false"); - } else if (wld.getGameRuleValue("naturalRegeneration").equals("false")) { - wld.setGameRuleValue("naturalRegeneration", "true"); - nth.setGameRuleValue("naturalRegeneration", "true"); - end.setGameRuleValue("naturalRegeneration", "true"); - } - break; - default: - break; - } - chl.saveConfig(); - p.performCommand("settings"); - } - } - if (invname.equals(coco.CGUIN)) { - e.setCancelled(true); - if (slot >= 0 && slot <= 44) { - if (coco.CoordsGUI.getItem(slot) != null && p.hasPermission("challenges.coords.delete")) { - p.performCommand("coords delete " + e.getCurrentItem().getItemMeta().getDisplayName()); - } - } - } - if (invname.equals(coco.CDGUIN)) { - e.setCancelled(true); - if (slot == 0) { - String cname = coco.CoordsDeleteGUI.getItem(4).getItemMeta().getDisplayName(); - chl.getConfig().set("Saved_Locations." + cname, null); - chl.saveConfig(); - p.sendMessage("§cPosition §6" + cname + " §cwurde gelöscht!"); - p.closeInventory(); - } - if (slot == 8) { - p.performCommand("coords"); - } - } - } -} - diff --git a/src/main/java/net/brennholz/events/QuitJoinListener.java b/src/main/java/net/brennholz/events/QuitJoinListener.java deleted file mode 100644 index ae097fe..0000000 --- a/src/main/java/net/brennholz/events/QuitJoinListener.java +++ /dev/null @@ -1,44 +0,0 @@ -package net.brennholz.events; - - - -import java.util.Random; -import net.brennholz.challenges.Challenges; -import org.bukkit.Bukkit; -import org.bukkit.entity.Player; -import org.bukkit.event.EventHandler; -import org.bukkit.event.Listener; -import org.bukkit.event.player.PlayerJoinEvent; -import org.bukkit.event.player.PlayerQuitEvent; - -public class QuitJoinListener implements Listener { - - private Challenges chl = Challenges.getplugin(); - - - - @EventHandler - public void PlayerJoinEvent(PlayerJoinEvent e) { - Player p = e.getPlayer(); - e.setJoinMessage("§6" + p.getName() + " §chat den Server betreten!"); - if (chl.getConfig().getBoolean("sharedmg") == true) { - int rnd = new Random().nextInt(Bukkit.getOnlinePlayers().size()); - Player rp = (Player) Bukkit.getServer().getOnlinePlayers().toArray()[rnd]; - p.setHealth(rp.getHealth()); - } - if (this.chl.getConfig().getBoolean("tabhp") == true) { - this.chl.getSBManager().createScoreboard(p); - } - } - - @EventHandler - public void PlayerQuitEvent(PlayerQuitEvent e) { - Player p = e.getPlayer(); - e.setQuitMessage("§6" + p.getName() + " §chat den Server verlassen!"); - - if (Bukkit.getOnlinePlayers().size() == 1) { - chl.getConfig().set("timer.enabled", false); - chl.saveConfig(); - } - } -} diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml index d7859b4..ba20b36 100644 --- a/src/main/resources/config.yml +++ b/src/main/resources/config.yml @@ -7,20 +7,22 @@ sharedmg: false respawn: true onelife: false -dmginchat: false +dmginchat: true deathonsprint: false deathonjump: false +xpdeath: false clinvdmg: false -tabhp: true +tabhp: false tntdeath: false -#Mögliche werte: 9 18 27 36 45 54 -backpack_size: 27 -timer: +target: true +#Mögliche werte: 1-6 +backpack_size: 3 +mlg: enabled: false - time: 0 - sek: '00' - min: '00' - hrs: 0 + killall: false + maxtime: 600 +timertime: 0 Saved_Locations: {} World_Name: world -World_Reset: false \ No newline at end of file +World_Reset: false +event: false \ No newline at end of file diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml index 5799110..d4693c9 100644 --- a/src/main/resources/plugin.yml +++ b/src/main/resources/plugin.yml @@ -1,87 +1,49 @@ name: Challenges -main: net.brennholz.challenges.Challenges -version: 2.0 -api-version: 1.13 +main: ${mainClass} +version: ${project.version} load: STARTUP -author: Brennholz3000 +api-version: 1.16 +author: ${project.author} +depend: [CubesideUtils] commands: hp: description: Verwalte die HP eines Spielers usage: Benutze /hp get/add/remove/set/max [Spieler] [Wert] - permission: challenges.hp coords: description: Teile oder speichere deine Position! usage: Benutze /coords share/get/save/delete [Name] - permission: challenges.coords settings: description: Verwalte die Plugineinstellungen usage: Benutze /settings Get/Crafting/Trading/DeathFall/DMGOnSneak/Respawn/OneLife/ChatDMG [True/False] - permission: challenges.settings revive: description: Wiederbelebe einen gestorbenen Spieler! usage: Benutze /revive [world] [x] [y] [z] - permission: challenges.revive timer: description: Verwalte den Timer usage: Benutze /timer resume/pause/reset/set [Zeit in Sekunden] - permission: challenges.timer challenges: description: Main Command usage: Benutze /Challenges - permission: challenges.challenges backpack: description: Oeffne ein Backpack usage: Benutze /backpack oder /bp - permission: challenges.backpack aliases: [bp] reset: description: Setzte die Welt zurueck usage: Benutze /Reset - permission: challenges.reset - -permissions: - challenges.*: - description: Voller Zugriff auf das Challenge Plugin - default: op - children: - challenges.hp: true - challenges.coords: true - challenges.settings: true - challenges.revive: true - challenges.timer: true - challenges.challenges: true - challenges.reset: true - challenges.hp: - description: Verwalte die HP eines Spielers - default: op - challenges.coords: - description: Teile oder speichere deine Position! - default: op - children: - challenges.coords.view: true - challenges.coords.share: true - challenges.coords.get: true - challenges.coords.save: true - challenges.coords.delete: true - challenges.settings: - description: Verwalte die Plugineinstellungen - default: op - children: - challenges.settings.view: true - challenges.settings.get: true - challenges.settings.modify: true - challenges.revive: - description: Wiederbelebe einen gestorbenen Spieler! - default: op - challenges.timer: - description: Verwalte den Timer - default: op - challenges.challenges: - description: Main Command - default: op - challenges.backpack: - description: Oeffne ein Backpack - default: op - challenges.reset: - description: Setze die Welt zurueck - default: op \ No newline at end of file + forcemlg: + description: Triggert einen MLG + usage: Use /forcemlg + editor: + description: Editor Befehl + usage: Use /editor + leave: + description: Spiel verlassen + usage: Use /leave + aliases: [l] + kick: + description: Spieler Kicken + usage: Use /kick + event: + description: Event + usage: Use /event \ No newline at end of file