Force Item Battles now work for all Players

Windows fully abstracted
Simplified adding Minigames
Some other minor updates

src/main/java/de/ventority/randomizedminigames/GUI/BaseWindow.java

@@ -12,51 +12,63 @@ import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.persistence.PersistentDataContainer;
 import org.bukkit.persistence.PersistentDataType;
 
+import java.util.Objects;
+
 public abstract class BaseWindow {
-    private final Player p;
+    protected final Player p;
-    private final Inventory gui;
+    protected final Inventory gui;
-    private String status;
+    protected String status;
 
     public BaseWindow(Player p, String status) {
         this.p = p;
         gui = Bukkit.createInventory(p, 54, RandomizedMinigames.serverSettingsHandler.getServerName()
-                + ChatColor.RESET + ChatColor.DARK_GRAY + " " + status);
+                + ChatColor.RESET + ChatColor.DARK_GRAY + status);
         this.status = status;
     }
 
-    private void fillBorder() {
+    protected void fillBorder() {
-        ItemStack stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
+        ItemStack stack;
-        ItemMeta meta = stack.getItemMeta();
-        meta.setDisplayName(" ");
         for (int i = 0; i < 9; i++) {
-            gui.setItem(i, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
+            stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
-            gui.getItem(i).setItemMeta(meta);
+            gui.setItem(i, stack);
+            setItemName(stack, " " + i);
         }
         for (int i = 1; i < 5; i++) {
-            gui.setItem(9 * i, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
+            stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
-            gui.getItem(9 * i).setItemMeta(meta);
+            gui.setItem(9 * i, stack);
-            gui.setItem(8 + 9 * i, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
+            setItemName(stack, " " + 9 * i);
-            gui.getItem(8 + 9 * i).setItemMeta(meta);
+            stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
+            gui.setItem(8 + 9 * i, stack);
+            setItemName(stack, " " + 8 + 9 * i);
         }
         for (int i = 0; i < 9; i++) {
-            gui.setItem(i + 5 * 9, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
+            stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
-            gui.getItem(i + 5 * 9).setItemMeta(meta);
+            gui.setItem(i + 5 * 9, stack);
+            setItemName(stack, " " + i + 5 * 9);
         }
     }
 
-    public abstract void fillGUI();
+    protected abstract void fillGUI();
 
-    public void buildWindow() {
+    protected void buildWindow() {
         fillBorder();
         fillGUI();
+        addNBT(Objects.requireNonNull(gui.getItem(0)), "ItemMiniGame", "true");
         p.openInventory(gui);
     }
 
-    public ItemMeta addNBT(ItemMeta meta, String key, String value) {
+    protected void addNBT(ItemStack item, String key, String value) {
-        NamespacedKey namespacedKey = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), key);
+        ItemMeta meta = item.getItemMeta();
+        NamespacedKey key1 = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), key);
+        if (meta == null) return;
         PersistentDataContainer data = meta.getPersistentDataContainer();
-        data.set(namespacedKey, PersistentDataType.STRING, value);
+        data.set(key1, PersistentDataType.STRING, value);
-        return meta;
+    }
+
+    protected void setItemName(ItemStack item, String name) {
+        ItemMeta meta = item.getItemMeta();
+        if (meta == null) return;
+        meta.setDisplayName(name);
     }
 
     public Inventory getGUI() {

src/main/java/de/ventority/randomizedminigames/GUI/GUIClickEvent.java

@@ -1,12 +1,10 @@
 package de.ventority.randomizedminigames.GUI;
 
-
 import de.ventority.randomizedminigames.MinigameHandler;
 import de.ventority.randomizedminigames.Minigames.Minigame;
 import de.ventority.randomizedminigames.RandomizedMinigames;
-import org.bukkit.Bukkit;
-import org.bukkit.Material;
 import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.inventory.InventoryClickEvent;
@@ -22,51 +20,47 @@ public class GUIClickEvent implements Listener {
         Inventory inventory = event.getClickedInventory();
         if (inventory == null) return;
         if (inventory.getItem(0) == null) return;
-        ItemStack firstItem = inventory.getItem(0);
+        if (isMinigamePlugin(inventory.getItem(0))) {
-        if (hasNBTData(firstItem)) {
             event.setCancelled(true);
-            if (getStatus(firstItem).equals("selectMinigame")) {
+            event.getWhoClicked().closeInventory();
-                handleMinigame(event);
+            if (getNBT(event.getCurrentItem(), "Type").equals("Minigame")) {
+                handleMinigame(event, getNBT(event.getCurrentItem(), "Action"));
             }
-            if (getStatus(firstItem).equals("selectSettings")) {
+            if (getNBT(event.getCurrentItem(), "Type").equals("Misc")) {
-                handleSettings(event);
+                handleSettings(event, getNBT(event.getCurrentItem(), "Action"));
             }
         }
     }
 
-    private boolean hasNBTData(ItemStack item) {
+    private String getNBT(ItemStack item, String key) {
-        if (item == null || !item.hasItemMeta()) return false;
+        if (item == null) return "ItemIsNull";
-
         ItemMeta meta = item.getItemMeta();
-        NamespacedKey key = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), "IsMinigamePlugin");
+        NamespacedKey nsKey = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), key);
-        if (meta == null) return false;
+        if (meta == null) return "NoItemMeta";
         PersistentDataContainer data = meta.getPersistentDataContainer();
-        return "1".equals(data.get(key, PersistentDataType.STRING));
+        return data.get(nsKey, PersistentDataType.STRING);
     }
 
-    private String getStatus(ItemStack item) {
+    private boolean isMinigamePlugin(ItemStack item) {
-        if (item == null || !item.hasItemMeta()) return "";
+        String s = getNBT(item, "ItemMiniGame");
-        ItemMeta meta = item.getItemMeta();
+        System.out.println(s);
-        NamespacedKey key = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), "IsMinigamePlugin");
+        System.out.println(item.getItemMeta().getDisplayName());
-        if (meta == null) return "";
+        System.out.println(s != null && s.equals("true"));
-        PersistentDataContainer data = meta.getPersistentDataContainer();
+        return s != null && s.equals("true");
-        return data.get(key, PersistentDataType.STRING);
     }
 
-    private void handleMinigame(InventoryClickEvent event) {
+    private void handleMinigame(InventoryClickEvent event, String action) {
         for (Minigame minigame : Minigame.values()) {
-            if (event.getCurrentItem().getType() == minigame.getMaterial()) {
+            if (action.equals(minigame.getAction())) {
                 MinigameHandler.createMinigame(minigame.getNumber());
             }
         }
     }
 
-    private void handleSettings(InventoryClickEvent event) {
+    private void handleSettings(InventoryClickEvent event, String action) {
-        if (event.getCurrentItem() == null) return;
+        if (action.equals("selectSettings")) {
-        PersistentDataContainer data = event.getCurrentItem().getItemMeta().getPersistentDataContainer();
+            new SettingsWindow((Player)event.getWhoClicked(), "Settings");
-        NamespacedKey key = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), "State");
+        }
-        if (data.get(key, PersistentDataType.STRING).equals("addContestants")) {
 
     }
-    }
 }

src/main/java/de/ventority/randomizedminigames/GUI/MinigamesDisplayWindow.java

@@ -13,16 +13,10 @@ import org.bukkit.inventory.meta.ItemMeta;
 import org.bukkit.persistence.PersistentDataContainer;
 import org.bukkit.persistence.PersistentDataType;
 
-public class MinigamesDisplayWindow {
+public class MinigamesDisplayWindow extends BaseWindow{
-    private final Player p;
-    private final Inventory gui;
-    private String status;
 
     public MinigamesDisplayWindow(Player p, String status) {
-        this.p = p;
+        super(p, status);
-        gui = Bukkit.createInventory(p, 54, RandomizedMinigames.serverSettingsHandler.getServerName()
-                + ChatColor.RESET + ChatColor.DARK_GRAY + " Minigames");
-        this.status = status;
     }
 
     public void buildWindow() {
@@ -31,50 +25,27 @@ public class MinigamesDisplayWindow {
         p.openInventory(gui);
     }
 
-    private void fillGUI() {
+    @Override
+    protected void fillGUI() {
         for (Minigame minigame : Minigame.values()) {
             ItemStack item = new ItemStack(minigame.getMaterial(), 1);
             ItemMeta meta = item.getItemMeta();
-            assert meta != null;
+            setItemName(item, minigame.getName());
-            meta.setDisplayName(minigame.getName());
+            addNBT(item, "Type", "Minigame");
+            addNBT(item, "Action", minigame.getAction());
+            item.setItemMeta(meta);
             gui.addItem(item);
         }
+        addSettings();
     }
 
-    private void fillBorder() {
+    private void addSettings() {
-        ItemStack stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
-        ItemMeta meta = stack.getItemMeta();
-        meta.setDisplayName(" ");
-        for (int i = 0; i < 9; i++) {
-            gui.setItem(i, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
-            gui.getItem(i).setItemMeta(meta);
-        }
-        for (int i = 1; i < 5; i++) {
-            gui.setItem(9 * i, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
-            gui.getItem(9 * i).setItemMeta(meta);
-            gui.setItem(8 + 9 * i, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
-            gui.getItem(8 + 9 * i).setItemMeta(meta);
-        }
-        for (int i = 0; i < 9; i++) {
-            gui.setItem(i + 5 * 9, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
-            gui.getItem(i + 5 * 9).setItemMeta(meta);
-        }
-        ItemMeta meta1 = addNBT(gui.getItem(0).getItemMeta(), "Status", status);
-        meta1 = addNBT(meta1, "IsMinigamePlugin", "1");
-        gui.getItem(0).setItemMeta(meta1);
-
         ItemStack settings = new ItemStack(Material.REDSTONE, 1);
         ItemMeta settingsMeta = settings.getItemMeta();
-        settingsMeta.setDisplayName("Settings");
+        setItemName(settings, "Settings");
-        settingsMeta = addNBT(settingsMeta, "Status", "selectSettings");
+        addNBT(settings, "Type", "Misc");
+        addNBT(settings, "Action", "selectSettings");
         settings.setItemMeta(settingsMeta);
-        gui.setItem(9, settings);
+        gui.setItem(45, settings);
-    }
-
-    private ItemMeta addNBT(ItemMeta meta, String key, String value) {
-        NamespacedKey key1 = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), key);
-        PersistentDataContainer data = meta.getPersistentDataContainer();
-        data.set(key1, PersistentDataType.STRING, value);
-        return meta;
     }
 }

src/main/java/de/ventority/randomizedminigames/GUI/SettingsWindow.java

@@ -2,9 +2,7 @@ package de.ventority.randomizedminigames.GUI;
 
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
-import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
 
 public class SettingsWindow extends BaseWindow{
 
@@ -14,14 +12,9 @@ public class SettingsWindow extends BaseWindow{
 
     @Override
     public void fillGUI() {
-        Inventory gui = getGUI();
         ItemStack setContestants = new ItemStack(Material.ZOMBIE_HEAD, 1);
-        ItemMeta setContestantsMeta = setContestants.getItemMeta();
+        setItemName(setContestants, "Add Contestants");
-        setContestantsMeta.setDisplayName("Contestants");
+        addNBT(setContestants, "Status", "addContestants");
-        setContestantsMeta = addNBT(setContestantsMeta, "Status", "addContestants");
-        setContestants.setItemMeta(setContestantsMeta);
         gui.addItem(setContestants);
     }
-
-
 }

src/main/java/de/ventority/randomizedminigames/GeneralSettings.java

@@ -7,6 +7,6 @@ import java.util.List;
 
 public class GeneralSettings {
     public List<Player> contestants = new ArrayList<>();
-
+    public String keyword;
 
 }

src/main/java/de/ventority/randomizedminigames/MinigameHandler.java

@@ -1,20 +1,25 @@
 package de.ventority.randomizedminigames;
 
 import de.ventority.randomizedminigames.Minigames.ForceItemBattle;
+import de.ventority.randomizedminigames.Minigames.ForceItemBattleSameItems;
 import de.ventority.randomizedminigames.Minigames.MinigameBase;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import java.util.ArrayList;
 import java.util.List;
 
+
 import static org.bukkit.Bukkit.getServer;
 
 public class MinigameHandler {
-    private static List<MinigameBase> minigames = new ArrayList<>();
+    private static final List<MinigameBase> minigames = new ArrayList<>();
 
     public static void createMinigame(int gameNumber) {
         List<Player> players = Bukkit.getOnlinePlayers().stream().map(p -> ((Player) p)).toList();
-        minigames.add(new ForceItemBattle(players));
+        switch (gameNumber) {
+            case 0: minigames.add(new ForceItemBattle(players));
+            case 1: minigames.add(new ForceItemBattleSameItems(players));
+        }
         getServer().getPluginManager().registerEvents(minigames.getFirst(), RandomizedMinigames.serverSettingsHandler.getPlugin());
     }
 

src/main/java/de/ventority/randomizedminigames/Minigames/ForceItemBattle.java

@@ -2,6 +2,7 @@ package de.ventority.randomizedminigames.Minigames;
 
 import de.ventority.randomizedminigames.GUI.GamesScoreboardManager;
 import de.ventority.randomizedminigames.MinigameHandler;
+import de.ventority.randomizedminigames.misc.PlayerBackup;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
 import org.bukkit.Material;
@@ -14,19 +15,22 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityPickupItemEvent;
 import org.bukkit.event.inventory.CraftItemEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.inventory.ItemStack;
 
 import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Random;
 
 public class ForceItemBattle implements MinigameBase, Listener {
-    private final HashMap<Player, ItemStack> currentItems;
+    protected final HashMap<Player, ItemStack> currentItems;
-    private final HashMap<Player, Integer> currentScores;
+    protected final HashMap<Player, Integer> currentScores;
-    private final HashMap<Player, BossBar> itemDisplays;
+    protected final HashMap<Player, BossBar> itemDisplays;
     private final int id;
     private GamesScoreboardManager scoreboardManager;
     private final List<Player> contestants;
+    private final HashMap<Player, PlayerBackup> backups;
 
 
     public ForceItemBattle(List<Player> players) {
@@ -34,6 +38,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
         currentItems = new HashMap<>();
         currentScores = new HashMap<>();
         itemDisplays = new HashMap<>();
+        backups = new HashMap<>();
         contestants = players;
         for (Player player : players) {
             currentItems.put(player, null);
@@ -41,10 +46,10 @@ public class ForceItemBattle implements MinigameBase, Listener {
             BossBar bar = Bukkit.createBossBar("Hallo", BarColor.PURPLE, BarStyle.SOLID);
             bar.addPlayer(player);
             bar.setVisible(true);
-            bar.setTitle("Das ist ein Test");
             itemDisplays.put(player, bar);
             System.out.println(itemDisplays.get(player).getTitle());
             updatePlayerItem(player);
+            backups.put(player, new PlayerBackup(player.getInventory().getContents(), player.getInventory().getArmorContents(), player.getExp(), player.getLocation()));
         }
         scoreboardManager = new GamesScoreboardManager(players, getName());
     }
@@ -59,21 +64,6 @@ public class ForceItemBattle implements MinigameBase, Listener {
         return "Force Item Battle";
     }
 
-    @Override
-    public int getPlayerIntervals() {
-        return 0;
-    }
-
-    @Override
-    public int getMinPlayers() {
-        return 2;
-    }
-
-    @Override
-    public int getMaxPlayers() {
-        return -1;
-    }
-
     @Override
     public ItemStack getSymbol() {
         return new ItemStack(Material.DIAMOND_SWORD, 1);
@@ -84,7 +74,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
 
     }
 
-    private ItemStack getRandomItem() {
+    protected ItemStack getRandomItem() {
         Material m;
         do {
             int i = new Random().nextInt(0, Material.values().length);
@@ -93,7 +83,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
         return new ItemStack(m);
     }
 
-    private void checkItem(Player p, ItemStack i) {
+    protected void checkItem(Player p, ItemStack i) {
         if (i == null) return;
         if (currentItems.get(p).getType() == i.getType()) {
             currentScores.replace(p, currentScores.get(p) + 1);
@@ -105,7 +95,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
         }
     }
 
-    private void updatePlayerItem(Player player) {
+    protected void updatePlayerItem(Player player) {
         currentItems.replace(player, getRandomItem());
         String key = currentItems.get(player).getType().getTranslationKey();
         String displayName = key.replace("block.minecraft.", "")
@@ -130,7 +120,8 @@ public class ForceItemBattle implements MinigameBase, Listener {
             if (player != winner) {
                 player.teleport(winner);
                 player.setGameMode(GameMode.SPECTATOR);
-                
+                player.sendTitle(winner.getDisplayName() + " hat gewonnen!", "Die Player werden jetzt zurückgesetzt.", 10, 70, 20);
+                restorePlayer(player);
             }
         }
         for (Player p : itemDisplays.keySet()) {
@@ -141,13 +132,24 @@ public class ForceItemBattle implements MinigameBase, Listener {
 
         scoreboardManager.removeScoreboard();
         scoreboardManager = null;
-
-        for (Player player : contestants) {
-            player.sendTitle(winner.getDisplayName() + " hat gewonnen!", "Die Player werden jetzt zurückgesetzt.", 10, 70, 20);
-        }
         MinigameHandler.deleteGame(this);
     }
 
+    private void removePlayer(Player p) {
+        itemDisplays.get(p).setVisible(false);
+        itemDisplays.get(p).removePlayer(p);
+        scoreboardManager.getScoreboard().getPlayers().remove(p);
+    }
+
+    private void restorePlayer(Player p) {
+        PlayerBackup backup = backups.get(p);
+        p.teleport(backup.getLocation());
+        p.setExp(backup.getExp());
+        p.getInventory().clear();
+        p.getInventory().setContents(backup.getInventory());
+        p.getInventory().setArmorContents(backup.getArmor());
+    }
+
     @EventHandler
     public void onItemPickup(EntityPickupItemEvent e) {
         Player eventPlayer;
@@ -167,4 +169,11 @@ public class ForceItemBattle implements MinigameBase, Listener {
         if (currentItems.containsKey(p))
             checkItem(p, e.getCurrentItem());
     }
+    @EventHandler
+    public void onPlayerLeave(PlayerQuitEvent e) {
+        if (contestants.contains(e.getPlayer())) {
+            removePlayer(e.getPlayer());
+            restorePlayer(e.getPlayer());
+        }
+    }
 }

src/main/java/de/ventority/randomizedminigames/Minigames/ForceItemBattleSameItems.java

@@ -0,0 +1,34 @@
+package de.ventority.randomizedminigames.Minigames;
+
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ForceItemBattleSameItems extends ForceItemBattle {
+    private  List<ItemStack> items;
+
+
+    public ForceItemBattleSameItems(List<Player> players) {
+        super(players);
+    }
+
+    @Override
+    protected void updatePlayerItem(Player player) {
+        if (this.items == null || this.items.isEmpty()) {
+            items = new ArrayList<>();
+            items.add(getRandomItem());
+        }
+        if (currentScores.get(player) == items.size()) {
+            items.add(getRandomItem());
+        }
+        currentItems.replace(player, items.get(currentScores.get(player)));
+        String key = currentItems.get(player).getType().getTranslationKey();
+        itemDisplays.get(player).setTitle(key.replace("block.minecraft.", "")
+                                                .replace("_", " ")
+                                                .replace("item.minecraft.", ""));
+        for (ItemStack item : player.getInventory().getContents())
+            checkItem(player, item);
+    }
+}

src/main/java/de/ventority/randomizedminigames/Minigames/Minigame.java

@@ -3,15 +3,19 @@ package de.ventority.randomizedminigames.Minigames;
 import org.bukkit.Material;
 
 public enum Minigame {
-    ForceItemBattle(Material.DIAMOND_SWORD, "Force Item Battle", 0);
+    ForceItemBattle(Material.DIAMOND_SWORD, "Force Item Battle", 0, "startForceItem"),
+    ForceItemBattleSameItems(Material.NETHERITE_SWORD, "Force Item Battle (Same Items)", 1, "startForceItemSameItem"),;
 
-    Material material;
+    final Material material;
-    String name;
+    final String name;
-    int number;
+    final int number;
-    Minigame(Material m, String s, int i) {
+    final String action;
+
+    Minigame(Material m, String s, int i, String action) {
         material = m;
         name = s;
         number = i;
+        this.action = action;
     }
 
     public Material getMaterial() {
@@ -25,4 +29,8 @@ public enum Minigame {
     public int getNumber() {
         return number;
     }
+
+    public String getAction() {
+        return action;
+    }
 }

src/main/java/de/ventority/randomizedminigames/Minigames/MinigameBase.java

@@ -9,9 +9,6 @@ import java.util.List;
 public interface MinigameBase extends Listener {
     int getID();
     String getName();
-    int getPlayerIntervals();
-    int getMinPlayers();
-    int getMaxPlayers();
     ItemStack getSymbol();
     void addPlayers(List<Player> players);
 }

src/main/java/de/ventority/randomizedminigames/RandomizedMinigames.java

@@ -5,6 +5,7 @@ import org.bukkit.plugin.java.JavaPlugin;
 
 public final class RandomizedMinigames extends JavaPlugin {
     public static final ServerSettingsHandler serverSettingsHandler = new ServerSettingsHandler();
+    public static String keyword = "";
     @Override
     public void onEnable() {
         init();

src/main/java/de/ventority/randomizedminigames/misc/PlayerBackup.java

@@ -0,0 +1,35 @@
+package de.ventority.randomizedminigames.misc;
+
+import org.bukkit.Location;
+import org.bukkit.inventory.ItemStack;
+
+public class PlayerBackup {
+    private final ItemStack[] inventory;
+    private final ItemStack[] armor;
+    private final float exp;
+    private final Location location;
+
+    public PlayerBackup(ItemStack[] inventory, ItemStack[] armor, float exp, Location location) {
+        this.inventory = inventory;
+        this.armor = armor;
+        this.exp = exp;
+        this.location = location;
+    }
+
+    public ItemStack[] getInventory() {
+        return inventory;
+    }
+
+    public ItemStack[] getArmor() {
+        return armor;
+    }
+
+    public float getExp() {
+        return exp;
+    }
+
+    public Location getLocation() {
+        return location;
+    }
+
+}