Initial commit

Plugins/Old/Challenge/src/de/craftix/challenge/Main.java

@@ -0,0 +1,140 @@
+package de.craftix.challenge;
+
+import de.craftix.challenge.commands.Additem;
+import de.craftix.challenge.commands.Invsee;
+import de.craftix.challenge.commands.Items;
+import de.craftix.challenge.commands.Position;
+import de.craftix.challenge.listener.onDeath;
+import de.craftix.challenge.listener.onInv;
+import de.craftix.challenge.listener.onStart;
+import de.craftix.challenge.listener.onWin;
+import de.craftix.challenge.utils.Timer;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.ArrayList;
+
+public class Main extends JavaPlugin {
+    public static ArrayList<Material> items = new ArrayList<>();
+
+    private static Main instance;
+    private static Timer timer;
+
+    @Override
+    public void onEnable() {
+        instance = this;
+        timer = new Timer();
+        PluginManager pm = Bukkit.getPluginManager();
+
+        getCommand("timer").setExecutor(timer);
+        getCommand("additem").setExecutor(new Additem());
+        getCommand("position").setExecutor(new Position());
+        getCommand("invsee").setExecutor(new Invsee());
+
+        pm.registerEvents(new onInv(), this);
+        pm.registerEvents(new onDeath(), this);
+        pm.registerEvents(new onWin(), this);
+        pm.registerEvents(new onStart(), this);
+
+        Items item = new Items();
+        getCommand("items").setExecutor(item);
+        pm.registerEvents(item, this);
+
+        addItems();
+    }
+
+    public static Main getInstance() {
+        return instance;
+    }
+
+    public static Timer getTimer() {
+        return timer;
+    }
+
+    public static void loose(){
+        timer.stop();
+        for (Player p : Bukkit.getOnlinePlayers()){
+            p.setGameMode(GameMode.SPECTATOR);
+        }
+    }
+
+    public static void win(){
+        timer.stop();
+        for (Player p : Bukkit.getOnlinePlayers()){
+            p.setGameMode(GameMode.SPECTATOR);
+        }
+        Bukkit.broadcastMessage("§6Die Challenge wurde erfolgreich absolviert");
+    }
+
+    public static void addItems(){
+        items.add(Material.OAK_LOG);
+        items.add(Material.SPRUCE_LOG);
+        items.add(Material.BIRCH_LOG);
+        items.add(Material.JUNGLE_LOG);
+        items.add(Material.ACACIA_LOG);
+        items.add(Material.DARK_OAK_LOG);
+        items.add(Material.CRIMSON_STEM);
+        items.add(Material.WARPED_STEM);
+        items.add(Material.OAK_PLANKS);
+        items.add(Material.SPRUCE_PLANKS);
+        items.add(Material.BIRCH_PLANKS);
+        items.add(Material.JUNGLE_PLANKS);
+        items.add(Material.ACACIA_PLANKS);
+        items.add(Material.DARK_OAK_PLANKS);
+        items.add(Material.WARPED_PLANKS);
+        items.add(Material.CRIMSON_PLANKS);
+        items.add(Material.OAK_SLAB);
+        items.add(Material.SPRUCE_SLAB);
+        items.add(Material.BIRCH_SLAB);
+        items.add(Material.JUNGLE_SLAB);
+        items.add(Material.ACACIA_SLAB);
+        items.add(Material.DARK_OAK_SLAB);
+        items.add(Material.WARPED_SLAB);
+        items.add(Material.CRIMSON_SLAB);
+        items.add(Material.OAK_STAIRS);
+        items.add(Material.SPRUCE_STAIRS);
+        items.add(Material.BIRCH_STAIRS);
+        items.add(Material.JUNGLE_STAIRS);
+        items.add(Material.ACACIA_STAIRS);
+        items.add(Material.DARK_OAK_STAIRS);
+        items.add(Material.WARPED_STAIRS);
+        items.add(Material.CRIMSON_STAIRS);
+        items.add(Material.OAK_FENCE);
+        items.add(Material.SPRUCE_FENCE);
+        items.add(Material.BIRCH_FENCE);
+        items.add(Material.JUNGLE_FENCE);
+        items.add(Material.ACACIA_FENCE);
+        items.add(Material.DARK_OAK_FENCE);
+        items.add(Material.WARPED_FENCE);
+        items.add(Material.CRIMSON_FENCE);
+        items.add(Material.OAK_PRESSURE_PLATE);
+        items.add(Material.SPRUCE_PRESSURE_PLATE);
+        items.add(Material.BIRCH_PRESSURE_PLATE);
+        items.add(Material.JUNGLE_PRESSURE_PLATE);
+        items.add(Material.ACACIA_PRESSURE_PLATE);
+        items.add(Material.DARK_OAK_PRESSURE_PLATE);
+        items.add(Material.WARPED_PRESSURE_PLATE);
+        items.add(Material.CRIMSON_PRESSURE_PLATE);
+        items.add(Material.OAK_BUTTON);
+        items.add(Material.SPRUCE_BUTTON);
+        items.add(Material.BIRCH_BUTTON);
+        items.add(Material.JUNGLE_BUTTON);
+        items.add(Material.ACACIA_BUTTON);
+        items.add(Material.DARK_OAK_BUTTON);
+        items.add(Material.WARPED_BUTTON);
+        items.add(Material.CRIMSON_BUTTON);
+        items.add(Material.COMPOSTER);
+        items.add(Material.CRAFTING_TABLE);
+        items.add(Material.CHEST);
+        items.add(Material.LADDER);
+        items.add(Material.WOODEN_AXE);
+        items.add(Material.WOODEN_HOE);
+        items.add(Material.WOODEN_PICKAXE);
+        items.add(Material.WOODEN_SHOVEL);
+        items.add(Material.WOODEN_SWORD);
+    }
+}

Plugins/Old/Challenge/src/de/craftix/challenge/commands/Additem.java

@@ -0,0 +1,20 @@
+package de.craftix.challenge.commands;
+
+import de.craftix.challenge.Main;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class Additem implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String s, String[] args) {
+        if (!(sender instanceof Player)) return false;
+        Player p = (Player)sender;
+        if (!p.hasPermission("challenge.additem")) return false;
+        Main.items.add(p.getInventory().getItemInMainHand().getType());
+        p.sendMessage("§aDas Item wurde in die Liste ver Verbotenen Items aufgenommen");
+        return false;
+    }
+}

Plugins/Old/Challenge/src/de/craftix/challenge/commands/Invsee.java

@@ -0,0 +1,24 @@
+package de.craftix.challenge.commands;
+
+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 Invsee implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String s, String[] args) {
+        if (!sender.hasPermission("challenge.invsee")) return false;
+        if (!(sender instanceof Player)) return false;
+        if (args.length != 1) return false;
+        Player p = (Player)sender;
+        Player t = Bukkit.getPlayer(args[0]);
+        if (t == null){
+            p.sendMessage("§cSpieler konnte nicht gefunden werden");
+            return false;
+        }
+        p.openInventory(t.getInventory());
+        return false;
+    }
+}

Plugins/Old/Challenge/src/de/craftix/challenge/commands/Items.java

@@ -0,0 +1,117 @@
+package de.craftix.challenge.commands;
+
+import de.craftix.challenge.Main;
+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.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.ArrayList;
+
+public class Items implements CommandExecutor, Listener {
+    private final String name = "Items";
+    private final int size = 9*3;
+    private ArrayList<Inventory> invs = new ArrayList<>();
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String s, String[] args) {
+        if (!(sender instanceof Player)) return false;
+        Player p = (Player)sender;
+        ArrayList<ItemStack> items = new ArrayList<>();
+        for (Material m : Main.items){
+            items.add(new ItemStack(m));
+        }
+        createInvs(items);
+        showInv(1, p);
+        return false;
+    }
+
+    @EventHandler
+    public void onInvClick(InventoryClickEvent event){
+        try {
+            if (!event.getView().getTitle().equalsIgnoreCase(name)) return;
+            event.setCancelled(true);
+            if (event.getCurrentItem() == null) return;
+            ItemStack clickedItem = event.getCurrentItem();
+            if (clickedItem.getType().equals(Material.GREEN_STAINED_GLASS_PANE)){
+                int invCount = Integer.parseInt(clickedItem.getItemMeta().getLore().get(0)) - 1;
+                showInv(invCount + 1, (Player) event.getWhoClicked());
+            }
+            if (clickedItem.getType().equals(Material.RED_STAINED_GLASS_PANE)){
+                int invCount = Integer.parseInt(clickedItem.getItemMeta().getLore().get(0)) - 1;
+                showInv(invCount + 1, (Player) event.getWhoClicked());
+            }
+        }catch (Exception e){
+
+        }
+    }
+
+    private void showInv(int id, Player p){
+        p.openInventory(invs.get(id - 1));
+    }
+
+    private void createInvs(ArrayList<ItemStack> items){
+        if (items.size() <= 0) return;
+        invs.clear();
+        while (true){
+            Inventory inv = Bukkit.createInventory(null, size, name);
+            inv.setItem(45, getItems(2, invs.size()));
+            inv.setItem(46, getItems(3, invs.size()));
+            inv.setItem(47, getItems(3, invs.size()));
+            inv.setItem(48, getItems(3, invs.size()));
+            inv.setItem(49, getItems(3, invs.size()));
+            inv.setItem(50, getItems(3, invs.size()));
+            inv.setItem(51, getItems(3, invs.size()));
+            inv.setItem(52, getItems(3, invs.size()));
+            inv.setItem(53, getItems(1, invs.size()));
+            for (int i = 0; i < inv.getSize(); i++){
+                if (items.size() <= 0) break;
+                if (inv.getItem(i) != null) continue;
+                inv.setItem(i, items.get(0));
+                items.remove(0);
+            }
+            invs.add(inv);
+            if (items.size() <= 0) break;
+        }
+    }
+
+    private ItemStack getItems(int color, int index){
+        if (color == 1){
+            ItemStack i = new ItemStack(Material.GREEN_STAINED_GLASS_PANE);
+            ItemMeta im = i.getItemMeta();
+            im.setDisplayName("§aNächste Seite");
+            ArrayList<String> lore = new ArrayList<>();
+            int ram = index + 2;
+            lore.add(String.valueOf(ram));
+            im.setLore(lore);
+            i.setItemMeta(im);
+            return i;
+        }
+        if (color == 2){
+            ItemStack i = new ItemStack(Material.RED_STAINED_GLASS_PANE);
+            ItemMeta im = i.getItemMeta();
+            im.setDisplayName("§cVorherige Seite");
+            ArrayList<String> lore = new ArrayList<>();
+            int ram = index;
+            lore.add(String.valueOf(ram));
+            im.setLore(lore);
+            i.setItemMeta(im);
+            return i;
+        }
+        if (color == 3){
+            ItemStack i = new ItemStack(Material.GRAY_STAINED_GLASS_PANE);
+            ItemMeta im = i.getItemMeta();
+            im.setDisplayName(" ");
+            i.setItemMeta(im);
+            return i;
+        }
+        return null;
+    }
+}

Plugins/Old/Challenge/src/de/craftix/challenge/commands/Position.java

@@ -0,0 +1,28 @@
+package de.craftix.challenge.commands;
+
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.HashMap;
+
+public class Position implements CommandExecutor {
+    private HashMap<String, Location> positions = new HashMap<>();
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String s, String[] args) {
+        if (!(sender instanceof Player)) return false;
+        Player p = (Player)sender;
+        if (args.length != 1) return false;
+        if (positions.containsKey(args[0])){
+            Location loc = positions.get(args[0]);
+            p.sendMessage("§aDie Position " + args[0] + " Befindet sich bei §b" + loc.getBlockX() + " " + loc.getBlockY() + " " + loc.getBlockZ());
+        }else {
+            positions.put(args[0], p.getLocation());
+            p.sendMessage("§aDie Position §6" + args[0] + " §awurde erfolgreich gespeichert");
+        }
+        return false;
+    }
+}

Plugins/Old/Challenge/src/de/craftix/challenge/listener/onDeath.java

@@ -0,0 +1,16 @@
+package de.craftix.challenge.listener;
+
+import de.craftix.challenge.Main;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+
+public class onDeath implements Listener {
+
+    @EventHandler
+    public void onDeathEvent(PlayerDeathEvent event){
+        if (!Main.getTimer().isStarted) return;
+        Main.loose();
+    }
+
+}

Plugins/Old/Challenge/src/de/craftix/challenge/listener/onInv.java

@@ -0,0 +1,38 @@
+package de.craftix.challenge.listener;
+
+import de.craftix.challenge.Main;
+import org.bukkit.GameMode;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityPickupItemEvent;
+import org.bukkit.event.inventory.InventoryClickEvent;
+
+public class onInv implements Listener {
+
+    @EventHandler
+    public void onInvClick(InventoryClickEvent event){
+        if (!Main.getTimer().isStarted) return;
+        if (event.getWhoClicked().getGameMode().equals(GameMode.SPECTATOR)) return;
+        for (Material m : Main.items){
+            if (event.getCurrentItem().getType().equals(m)) {
+                event.setCancelled(true);
+                Main.loose();
+            }
+        }
+    }
+
+    @EventHandler
+    public void onPickUp(EntityPickupItemEvent event){
+        if (!Main.getTimer().isStarted) return;
+        if (event.getEntity() instanceof Player){
+            Player p = (Player)event.getEntity();
+            if (p.getGameMode().equals(GameMode.SPECTATOR)) return;
+            for (Material m : Main.items){
+                if (event.getItem().getItemStack().getType().equals(m)) Main.loose();
+            }
+        }
+    }
+
+}

Plugins/Old/Challenge/src/de/craftix/challenge/listener/onStart.java

@@ -0,0 +1,47 @@
+package de.craftix.challenge.listener;
+
+import de.craftix.challenge.Main;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.FoodLevelChangeEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+
+public class onStart implements Listener {
+
+    @EventHandler
+    public void onBuild(BlockPlaceEvent event){
+        if (Main.getTimer().isStarted) return;
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onBreak(BlockBreakEvent event){
+        if (Main.getTimer().isStarted) return;
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onInteract(PlayerInteractEvent event){
+        if (Main.getTimer().isStarted) return;
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onDamage(EntityDamageEvent event){
+        if (Main.getTimer().isStarted) return;
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onFood(FoodLevelChangeEvent event){
+        if (Main.getTimer().isStarted) return;
+        event.setCancelled(true);
+        Player p = (Player)event.getEntity();
+        p.setFoodLevel(25);
+    }
+
+}

Plugins/Old/Challenge/src/de/craftix/challenge/listener/onWin.java

@@ -0,0 +1,18 @@
+package de.craftix.challenge.listener;
+
+import de.craftix.challenge.Main;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDeathEvent;
+
+public class onWin implements Listener {
+
+    @EventHandler
+    public void onDeath(EntityDeathEvent event){
+        if (!Main.getTimer().isStarted) return;
+        if (!(event.getEntity() instanceof EnderDragon)) return;
+        Main.win();
+    }
+
+}

Plugins/Old/Challenge/src/de/craftix/challenge/utils/ActionBar.java

@@ -0,0 +1,12 @@
+package de.craftix.challenge.utils;
+
+import net.md_5.bungee.api.ChatMessageType;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.entity.Player;
+
+
+public class ActionBar {
+    public static void show(Player p, String msg){
+        p.spigot().sendMessage(ChatMessageType.ACTION_BAR, new TextComponent(msg));
+    }
+}

Plugins/Old/Challenge/src/de/craftix/challenge/utils/Timer.java

@@ -0,0 +1,109 @@
+package de.craftix.challenge.utils;
+
+import de.craftix.challenge.Main;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class Timer implements CommandExecutor {
+
+    private Integer id;
+    private Integer stopID;
+    public int seconds = 0;
+    public int minutes = 0;
+    public int hours = 0;
+    public boolean isStarted = false;
+
+    public Timer(){
+        stopID = Bukkit.getScheduler().scheduleSyncRepeatingTask(Main.getInstance(), new Runnable() {
+            @Override
+            public void run() {
+                for (Player p : Bukkit.getOnlinePlayers()){
+                    ActionBar.show(p, "§6Der Timer ist pausiert");
+                }
+            }
+        }, 1, 20);
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String s, String[] args) {
+        if (sender instanceof Player){
+            Player p = (Player)sender;
+            if (p.hasPermission("challenge.timer")){
+                if (args[0].equalsIgnoreCase("start") || args[0].equalsIgnoreCase("resume")){
+                    start();
+                }else if (args[0].equalsIgnoreCase("stop")){
+                    stop();
+                }else if (args[0].equalsIgnoreCase("reset")){
+                    reset();
+                }
+            }
+        }
+        return false;
+    }
+
+    public void start(){
+        isStarted = true;
+        for (Player all : Bukkit.getOnlinePlayers()){
+            if (!all.getGameMode().equals(GameMode.SPECTATOR)) all.setGameMode(GameMode.SURVIVAL);
+        }
+        try {
+            Bukkit.getScheduler().cancelTask(stopID);
+            id = Bukkit.getScheduler().scheduleSyncRepeatingTask(Main.getInstance(), new Runnable() {
+                @Override
+                public void run() {
+                    seconds++;
+                    if (seconds >= 60){
+                        seconds = 0;
+                        minutes++;
+                    }
+                    if (minutes >= 60){
+                        minutes = 0;
+                        hours++;
+                    }
+                    for (Player p : Bukkit.getOnlinePlayers()){
+                        String SHours;
+                        String SMinutes;
+                        String SSeconds;
+                        if (seconds <= 9) SSeconds = "0" + seconds;
+                        else SSeconds = "" + seconds;
+                        if (minutes <= 9) SMinutes = "0" + minutes;
+                        else SMinutes = "" + minutes;
+                        if (hours <= 9) SHours = "0" + hours;
+                        else SHours = "" + hours;
+
+                        ActionBar.show(p, "§aChallenge: §b" + SHours + ":" + SMinutes + ":" + SSeconds);
+                    }
+                }
+            }, 1, 20);
+        }catch (Exception e){
+            System.err.println(e.toString());
+        }
+    }
+
+    public void stop(){
+        isStarted = false;
+        try {
+            Bukkit.getScheduler().cancelTask(id);
+            stopID = Bukkit.getScheduler().scheduleSyncRepeatingTask(Main.getInstance(), new Runnable() {
+                @Override
+                public void run() {
+                    for (Player p : Bukkit.getOnlinePlayers()){
+                        ActionBar.show(p, "§6Der Timer ist pausiert");
+                    }
+                }
+            }, 1, 20);
+        }catch (Exception e){
+            System.err.println(e.toString());
+        }
+    }
+
+    public void reset(){
+        seconds = 0;
+        minutes = 0;
+        hours = 0;
+    }
+}

Plugins/Old/Challenge/src/plugin.yml

@@ -0,0 +1,11 @@
+name: Item-Challenge
+main: de.craftix.challenge.Main
+version: 1.0.0
+api-version: 1.16
+
+commands:
+  timer:
+  additem:
+  position:
+  items:
+  invsee: