Initial commit

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,42 @@
+
+*.class
+
+
+*.log
+
+
+*.ctxt
+
+
+.mtj.tmp/
+
+
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+*.iml
+
+
+hs_err_pid*
+
+
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+*.classpath
+*.project
+local.properties
+.settings/
+.loadpath
+dependency-reduced-pom.xml
+.recommenders
+.idea/
+target/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Ajneb97
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,2 @@
+# PlayerKits2
+ 

pom.xml

@@ -0,0 +1,103 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>pk.ajneb97</groupId>
+    <artifactId>PlayerKits2</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <repositories>
+        <repository>
+            <id>spigot-repo</id>
+            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
+        </repository>
+        <repository>
+            <id>placeholderapi</id>
+            <url>https://repo.extendedclip.com/content/repositories/placeholderapi/</url>
+        </repository>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </repository>
+        <repository>
+            <id>minecraft-repo</id>
+            <url>https://libraries.minecraft.net/</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-api</artifactId>
+            <version>1.20.1-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>me.clip</groupId>
+            <artifactId>placeholderapi</artifactId>
+            <version>2.11.1</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.github.MilkBowl</groupId>
+            <artifactId>VaultAPI</artifactId>
+            <version>1.7</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.mojang</groupId>
+            <artifactId>authlib</artifactId>
+            <version>1.5.25</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>4.0.3</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.8.1</version>
+                <configuration>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.2.4</version>
+                <configuration>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <relocations>
+                                <relocation>
+                                    <pattern>com.zaxxer.HikariCP</pattern>
+                                    <shadedPattern>pk.ajneb97.libs.hikaricp</shadedPattern>
+                                </relocation>
+                            </relocations>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

src/main/java/pk/ajneb97/MainCommand.java

@@ -0,0 +1,320 @@
+package pk.ajneb97;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import pk.ajneb97.managers.MessagesManager;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.model.internal.GiveKitInstructions;
+import pk.ajneb97.model.internal.PlayerKitsMessageResult;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+import pk.ajneb97.utils.PlayerUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MainCommand implements CommandExecutor, TabCompleter {
+
+    private PlayerKits2 plugin;
+    public MainCommand(PlayerKits2 plugin) {
+        this.plugin = plugin;
+    }
+
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        MessagesManager msgManager = plugin.getMessagesManager();
+        FileConfiguration messagesConfig = plugin.getConfigsManager().getMessagesConfigManager().getConfig();
+
+        if (!(sender instanceof Player)) {
+            if (args.length >= 1) {
+                if (args[0].equalsIgnoreCase("reload")) {
+                    reload(sender,args,messagesConfig,msgManager);
+                }else if(args[0].equalsIgnoreCase("give")) {
+                    give(sender,args,messagesConfig,msgManager);
+                }else if(args[0].equalsIgnoreCase("delete")) {
+                    delete(sender,args,messagesConfig,msgManager);
+                }else if(args[0].equalsIgnoreCase("reset")) {
+                    reset(sender,args,messagesConfig,msgManager);
+                }else{
+                    help(sender,msgManager,messagesConfig);
+                }
+            }
+            return true;
+        }
+
+        Player player = (Player) sender;
+
+        boolean claimKitShortCommand = plugin.getConfigsManager().getMainConfigManager().getConfig().getBoolean("claim_kit_short_command");
+
+        if(args.length >= 1){
+            if(args[0].equalsIgnoreCase("claim") && !claimKitShortCommand){
+                claim(player,args,messagesConfig,msgManager);
+            }else if(args[0].equalsIgnoreCase("create")){
+                create(player,args,messagesConfig,msgManager);
+            }else if(args[0].equalsIgnoreCase("give")) {
+                give(player,args,messagesConfig,msgManager);
+            }else if(args[0].equalsIgnoreCase("delete")) {
+                delete(player,args,messagesConfig,msgManager);
+            }else if(args[0].equalsIgnoreCase("reload")) {
+                reload(player,args,messagesConfig,msgManager);
+            }else if(args[0].equalsIgnoreCase("reset")) {
+                reset(sender,args,messagesConfig,msgManager);
+            }else if(args[0].equalsIgnoreCase("edit")) {
+                edit(player,args,messagesConfig,msgManager);
+            }
+            else{
+                // /kit <kit> (short command)
+                if(claimKitShortCommand){
+                    claimKitShortCommand(player,messagesConfig,msgManager,args[0]);
+                    return true;
+                }else{
+                    help(sender,msgManager,messagesConfig);
+                }
+            }
+        }else{
+            // /kit
+            plugin.getInventoryManager().openInventory(new InventoryPlayer(player,"main_inventory"));
+        }
+
+
+        return true;
+    }
+
+    public void help(CommandSender sender,MessagesManager msgManager,FileConfiguration messagesConfig){
+        if(!PlayerUtils.isPlayerKitsAdmin(sender)){
+            msgManager.sendMessage(sender,messagesConfig.getString("commandDoesNotExists"),true);
+            return;
+        }
+        sender.sendMessage(MessagesManager.getColoredMessage("&7[ [ &8[&bPlayerKits&a²&8] &7] ]"));
+        sender.sendMessage(MessagesManager.getColoredMessage(" "));
+        sender.sendMessage(MessagesManager.getColoredMessage("&6/kit &8Opens the GUI."));
+        sender.sendMessage(MessagesManager.getColoredMessage("&6/kit claim <kit> &8Claims a kit outside the GUI."));
+        sender.sendMessage(MessagesManager.getColoredMessage("&6/kit create <kit> &8Creates a new kit using the items in your inventory."));
+        sender.sendMessage(MessagesManager.getColoredMessage("&6/kit edit <kit> &8Edits a kit."));
+        sender.sendMessage(MessagesManager.getColoredMessage("&6/kit give <kit> <player> &8Gives a kit to a player."));
+        sender.sendMessage(MessagesManager.getColoredMessage("&6/kit delete <kit> &8Deletes a kit."));
+        sender.sendMessage(MessagesManager.getColoredMessage("&6/kit reset <kit> <player> &8Resets kit data for a player."));
+        sender.sendMessage(MessagesManager.getColoredMessage("&6/kit reload &8Reloads the config."));
+        sender.sendMessage(MessagesManager.getColoredMessage(" "));
+        sender.sendMessage(MessagesManager.getColoredMessage("&7[ [ &8[&bPlayerKits&a²&8] &7] ]"));
+    }
+
+    public void reload(CommandSender sender,String[] args,FileConfiguration messagesConfig,MessagesManager msgManager){
+        if(!PlayerUtils.isPlayerKitsAdmin(sender)){
+            msgManager.sendMessage(sender,messagesConfig.getString("noPermissions"),true);
+            return;
+        }
+
+        if(!plugin.getConfigsManager().reload()){
+            sender.sendMessage(PlayerKits2.prefix+MessagesManager.getColoredMessage(" &cThere was an error reloading the config, check the console."));
+            return;
+        }
+        msgManager.sendMessage(sender,messagesConfig.getString("commandReload"),true);
+    }
+
+    public void reset(CommandSender sender,String[] args,FileConfiguration messagesConfig,MessagesManager msgManager) {
+        // /kits reset <kit> <player>
+        if(!PlayerUtils.isPlayerKitsAdmin(sender)) {
+            msgManager.sendMessage(sender, messagesConfig.getString("noPermissions"), true);
+            return;
+        }
+
+        if(args.length < 3) {
+            msgManager.sendMessage(sender, messagesConfig.getString("commandResetError"), true);
+            return;
+        }
+
+        String kitName = args[1];
+        String playerName = args[2];
+
+        PlayerKitsMessageResult result = plugin.getPlayerDataManager().resetKitForPlayer(playerName,kitName);
+        if(result.isError()){
+            msgManager.sendMessage(sender, result.getMessage(), true);
+        }else{
+            msgManager.sendMessage(sender, messagesConfig.getString("kitResetCorrect")
+                    .replace("%kit%",kitName).replace("%player%",playerName), true);
+        }
+    }
+
+    public void give(CommandSender sender,String[] args,FileConfiguration messagesConfig,MessagesManager msgManager){
+        // /kits give <kit> <player>
+        if(!PlayerUtils.isPlayerKitsAdmin(sender)){
+            msgManager.sendMessage(sender,messagesConfig.getString("noPermissions"),true);
+            return;
+        }
+
+        if(args.length < 3){
+            msgManager.sendMessage(sender,messagesConfig.getString("commandGiveError"),true);
+            return;
+        }
+
+        String kitName = args[1];
+        Player player = Bukkit.getPlayer(args[2]);
+        if(player == null){
+            msgManager.sendMessage(sender,messagesConfig.getString("playerNotOnline")
+                    .replace("%player%",args[2]),true);
+            return;
+        }
+
+        PlayerKitsMessageResult result = plugin.getKitsManager().giveKit(player,kitName,new GiveKitInstructions(true,false,false,false));
+        if(result.isError()){
+            msgManager.sendMessage(sender,messagesConfig.getString("commandGiveError2")
+                    .replace("%error%",result.getMessage()),true);
+        }else{
+            msgManager.sendMessage(sender,messagesConfig.getString("commandGiveCorrect")
+                    .replace("%kit%",kitName).replace("%player%",args[2]),true);
+        }
+    }
+
+    public void claim(Player player,String[] args,FileConfiguration messagesConfig,MessagesManager msgManager){
+        // /kit claim <kit>
+        if(args.length < 2){
+            msgManager.sendMessage(player,messagesConfig.getString("commandClaimError"),true);
+            return;
+        }
+
+        String kitName = args[1];
+        claimKitShortCommand(player,messagesConfig,msgManager,kitName);
+    }
+
+    public void claimKitShortCommand(Player player,FileConfiguration messagesConfig,MessagesManager msgManager,String kitName){
+        // /kit <kit>
+        PlayerKitsMessageResult result = plugin.getKitsManager().giveKit(player,kitName,new GiveKitInstructions());
+        if(result.isError()){
+            msgManager.sendMessage(player,result.getMessage(),true);
+        }else{
+            if(result.isProceedToBuy()){
+                //Open requirements inventory
+                InventoryPlayer inventoryPlayer = new InventoryPlayer(player,"buy_requirements_inventory");
+                inventoryPlayer.setKitName(kitName);
+                inventoryPlayer.setPreviousInventoryName("main_inventory");
+                plugin.getInventoryManager().openInventory(inventoryPlayer);
+                return;
+            }
+            msgManager.sendMessage(player,messagesConfig.getString("kitReceived").replace("%kit%",kitName),true);
+        }
+    }
+
+    public void create(Player player,String[] args,FileConfiguration messagesConfig,MessagesManager msgManager){
+        // /kit create <kit>
+        if(!PlayerUtils.isPlayerKitsAdmin(player)){
+            msgManager.sendMessage(player,messagesConfig.getString("noPermissions"),true);
+            return;
+        }
+
+        if(args.length < 2){
+            msgManager.sendMessage(player,messagesConfig.getString("commandCreateError"),true);
+            return;
+        }
+
+        plugin.getKitsManager().createKit(args[1],player);
+    }
+
+    public void delete(CommandSender sender,String[] args,FileConfiguration messagesConfig,MessagesManager msgManager){
+        // /kit delete <kit>
+        if(!PlayerUtils.isPlayerKitsAdmin(sender)){
+            msgManager.sendMessage(sender,messagesConfig.getString("noPermissions"),true);
+            return;
+        }
+
+        if(args.length < 2){
+            msgManager.sendMessage(sender,messagesConfig.getString("commandDeleteError"),true);
+            return;
+        }
+
+        plugin.getKitsManager().deleteKit(args[1],sender);
+    }
+
+    public void edit(Player player,String[] args,FileConfiguration messagesConfig,MessagesManager msgManager){
+        // /kit edit <kit>
+        if(!PlayerUtils.isPlayerKitsAdmin(player)){
+            msgManager.sendMessage(player,messagesConfig.getString("noPermissions"),true);
+            return;
+        }
+
+        if(args.length < 2){
+            msgManager.sendMessage(player,messagesConfig.getString("commandEditError"),true);
+            return;
+        }
+
+        if(plugin.getKitsManager().getKitByName(args[1]) == null){
+            msgManager.sendMessage(player,messagesConfig.getString("kitDoesNotExists")
+                    .replace("%kit%",args[1]),true);
+            return;
+        }
+
+        InventoryPlayer inventoryPlayer = new InventoryPlayer(player,null);
+        inventoryPlayer.setKitName(args[1]);
+        plugin.getInventoryEditManager().openInventory(inventoryPlayer);
+    }
+
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String label, String[] args) {
+        FileConfiguration configFile = plugin.getConfigsManager().getMainConfigManager().getConfig();
+        boolean claimKitShortCommand = configFile.getBoolean("claim_kit_short_command");
+
+        List<String> completions = new ArrayList<String>();
+        List<String> commands = new ArrayList<String>();
+
+        if(args.length == 1) {
+            if(claimKitShortCommand){
+                List<String> kitCompletions = getKitCompletions(sender,args,0);
+                if(kitCompletions != null){
+                    commands.addAll(kitCompletions);
+                }
+            }else{
+                commands.add("claim");
+            }
+            if(PlayerUtils.isPlayerKitsAdmin(sender)){
+                commands.add("give");commands.add("delete");commands.add("create");
+                commands.add("reload");commands.add("reset");commands.add("edit");
+            }
+            for(String c : commands) {
+                if(args[0].isEmpty() || c.startsWith(args[0].toLowerCase())) {
+                    completions.add(c);
+                }
+            }
+            return completions;
+        }else {
+            if(args.length == 2) {
+                if(!claimKitShortCommand){
+                    commands.add("claim");
+                }
+                if(PlayerUtils.isPlayerKitsAdmin(sender)){
+                    commands.add("give");commands.add("delete");
+                    commands.add("reset");commands.add("edit");
+                }
+                for(String c : commands) {
+                    if(args[0].equalsIgnoreCase(c)){
+                        return getKitCompletions(sender,args,1);
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public List<String> getKitCompletions(CommandSender sender,String[] args,int argKitPos){
+        List<String> completions = new ArrayList<>();
+        String argKit = args[argKitPos];
+
+        ArrayList<Kit> kits = plugin.getKitsManager().getKits();
+        for(Kit kit : kits) {
+            if(argKit.isEmpty() || kit.getName().toLowerCase().startsWith(argKit.toLowerCase())) {
+                if(kit.playerHasPermission(sender)){
+                    completions.add(kit.getName());
+                }
+            }
+        }
+
+        if(completions.isEmpty()){
+            return null;
+        }
+        return completions;
+    }
+}

src/main/java/pk/ajneb97/PlayerKits2.java

@@ -0,0 +1,139 @@
+
+package pk.ajneb97;
+
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+import pk.ajneb97.api.ExpansionPlayerKits;
+import pk.ajneb97.api.PlayerKitsAPI;
+import pk.ajneb97.configs.ConfigsManager;
+import pk.ajneb97.database.MySQLConnection;
+import pk.ajneb97.listeners.InventoryEditListener;
+import pk.ajneb97.listeners.PlayerListener;
+import pk.ajneb97.managers.*;
+import pk.ajneb97.managers.edit.InventoryEditManager;
+import pk.ajneb97.tasks.InventoryUpdateTaskManager;
+import pk.ajneb97.tasks.PlayerDataSaveTask;
+import pk.ajneb97.versions.NMSManager;
+
+public class PlayerKits2 extends JavaPlugin {
+
+    private String version = getDescription().getVersion();
+    public static String prefix = MessagesManager.getColoredMessage("&8[&bPlayerKits&a²&8] ");
+
+    private KitItemManager kitItemManager;
+    private KitsManager kitsManager;
+    private DependencyManager dependencyManager;
+    private ConfigsManager configsManager;
+    private MessagesManager messagesManager;
+    private PlayerDataManager playerDataManager;
+    private InventoryManager inventoryManager;
+    private InventoryEditManager inventoryEditManager;
+    private NMSManager nmsManager;
+
+
+    private InventoryUpdateTaskManager inventoryUpdateTaskManager;
+    private PlayerDataSaveTask playerDataSaveTask;
+    private MySQLConnection mySQLConnection;
+
+    public void onEnable(){
+        registerCommands();
+        registerEvents();
+
+        this.kitItemManager = new KitItemManager(this);
+        this.inventoryManager = new InventoryManager(this);
+        this.inventoryEditManager = new InventoryEditManager(this);
+        this.kitsManager = new KitsManager(this);
+        this.dependencyManager = new DependencyManager(this);
+        this.nmsManager = new NMSManager();
+        this.playerDataManager = new PlayerDataManager(this);
+
+        this.configsManager = new ConfigsManager(this);
+        this.configsManager.configure();
+
+        this.inventoryUpdateTaskManager = new InventoryUpdateTaskManager(this);
+        this.inventoryUpdateTaskManager.start();
+
+        if(configsManager.getMainConfigManager().isMySQL()){
+            mySQLConnection = new MySQLConnection(this);
+            mySQLConnection.setupMySql();
+        }else{
+            reloadPlayerDataSaveTask();
+        }
+
+        PlayerKitsAPI api = new PlayerKitsAPI(this);
+        if(getServer().getPluginManager().getPlugin("PlaceholderAPI") != null){
+            new ExpansionPlayerKits(this).register();
+        }
+
+        Bukkit.getConsoleSender().sendMessage(MessagesManager.getColoredMessage(prefix+"&eHas been enabled! &fVersion: "+version));
+        Bukkit.getConsoleSender().sendMessage(MessagesManager.getColoredMessage(prefix+"&eThanks for using my plugin!   &f~Ajneb97"));
+    }
+
+    public void onDisable(){
+        this.configsManager.getPlayersConfigManager().saveConfigs();
+        Bukkit.getConsoleSender().sendMessage(MessagesManager.getColoredMessage(prefix+"&eHas been disabled! &fVersion: "+version));
+    }
+
+    public void registerCommands(){
+        this.getCommand("kit").setExecutor(new MainCommand(this));
+    }
+
+    public void registerEvents() {
+        PluginManager pm = getServer().getPluginManager();
+        pm.registerEvents(new PlayerListener(this), this);
+        pm.registerEvents(new InventoryEditListener(this), this);
+    }
+
+    public void reloadPlayerDataSaveTask() {
+        if(playerDataSaveTask != null) {
+            playerDataSaveTask.end();
+        }
+        playerDataSaveTask = new PlayerDataSaveTask(this);
+        playerDataSaveTask.start(configsManager.getMainConfigManager().getConfig().getInt("player_data_save_time"));
+    }
+
+    public KitItemManager getKitItemManager() {
+        return kitItemManager;
+    }
+
+    public KitsManager getKitsManager() {
+        return kitsManager;
+    }
+
+    public MessagesManager getMessagesManager() {
+        return messagesManager;
+    }
+
+    public void setMessagesManager(MessagesManager messagesManager) {
+        this.messagesManager = messagesManager;
+    }
+
+    public ConfigsManager getConfigsManager() {
+        return configsManager;
+    }
+
+    public DependencyManager getDependencyManager() {
+        return dependencyManager;
+    }
+
+    public PlayerDataManager getPlayerDataManager() {
+        return playerDataManager;
+    }
+
+    public InventoryManager getInventoryManager() {
+        return inventoryManager;
+    }
+
+    public InventoryEditManager getInventoryEditManager() {
+        return inventoryEditManager;
+    }
+
+    public MySQLConnection getMySQLConnection() {
+        return mySQLConnection;
+    }
+
+    public NMSManager getNmsManager() {
+        return nmsManager;
+    }
+}

src/main/java/pk/ajneb97/api/ExpansionPlayerKits.java

@@ -0,0 +1,60 @@
+package pk.ajneb97.api;
+
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import org.bukkit.entity.Player;
+import pk.ajneb97.PlayerKits2;
+
+public class ExpansionPlayerKits extends PlaceholderExpansion {
+
+    // We get an instance of the plugin later.
+    private PlayerKits2 plugin;
+
+    public ExpansionPlayerKits(PlayerKits2 plugin) {
+    	this.plugin = plugin;
+    }
+
+    @Override
+    public boolean persist(){
+        return true;
+    }
+
+    @Override
+    public boolean canRegister(){
+        return true;
+    }
+
+    @Override
+    public String getAuthor(){
+        return "Ajneb97";
+    }
+
+    @Override
+    public String getIdentifier(){
+        return "playerkits";
+    }
+
+    @Override
+    public String getVersion(){
+        return plugin.getDescription().getVersion();
+    }
+
+    @Override
+    public String onPlaceholderRequest(Player player, String identifier){
+
+        if(player == null){
+            return "";
+        }
+
+        if(identifier.startsWith("cooldown_")){
+        	// %playerkits_cooldown_<kit>%
+        	String event = identifier.replace("cooldown_", "");
+            return PlayerKitsAPI.getKitCooldown(player,event);
+        }else if(identifier.startsWith("onetime_ready_")){
+            // %conditionalevents_onetime_ready_<kit>%
+            String event = identifier.replace("onetime_ready_", "");
+            return PlayerKitsAPI.getOneTimeReady(player,event);
+        }
+
+        return null;
+    }
+}

src/main/java/pk/ajneb97/api/PlayerKitsAPI.java

@@ -0,0 +1,50 @@
+package pk.ajneb97.api;
+
+import org.bukkit.entity.Player;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.MessagesManager;
+import pk.ajneb97.managers.PlayerDataManager;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.utils.PlayerUtils;
+
+public class PlayerKitsAPI {
+
+    private static PlayerKits2 plugin;
+    public PlayerKitsAPI(PlayerKits2 plugin){
+        this.plugin = plugin;
+    }
+
+    public static String getKitCooldown(Player player, String kitName){
+        Kit kit = plugin.getKitsManager().getKitByName(kitName);
+        MessagesManager messagesManager = plugin.getMessagesManager();
+
+        if(kit == null){
+            return null;
+        }
+
+        PlayerDataManager playerDataManager = plugin.getPlayerDataManager();
+        long playerCooldown = playerDataManager.getKitCooldown(player,kit.getName());
+        if(kit.getCooldown() != 0 && !PlayerUtils.isPlayerKitsAdmin(player)){
+            String timeStringMillisDif = playerDataManager.getKitCooldownString(playerCooldown);
+            if(!timeStringMillisDif.isEmpty()) {
+                return timeStringMillisDif;
+            }
+        }
+
+        return messagesManager.getCooldownPlaceholderReady();
+    }
+
+    public static String getOneTimeReady(Player player, String kitName){
+        Kit kit = plugin.getKitsManager().getKitByName(kitName);
+        if(kit == null){
+            return null;
+        }
+
+        boolean oneTime = plugin.getPlayerDataManager().isKitOneTime(player,kitName);
+        if(oneTime){
+            return "yes";
+        }else{
+            return "no";
+        }
+    }
+}

src/main/java/pk/ajneb97/configs/ConfigsManager.java

@@ -0,0 +1,71 @@
+package pk.ajneb97.configs;
+
+import pk.ajneb97.PlayerKits2;
+
+public class ConfigsManager {
+
+    private PlayerKits2 plugin;
+
+    private KitsConfigManager kitsConfigManager;
+    private MessagesConfigManager messagesConfigManager;
+    private MainConfigManager mainConfigManager;
+    private PlayersConfigManager playersConfigManager;
+    private InventoryConfigManager inventoryConfigManager;
+
+    public ConfigsManager(PlayerKits2 plugin){
+        this.plugin = plugin;
+        this.kitsConfigManager = new KitsConfigManager(plugin,"kits");
+        this.messagesConfigManager = new MessagesConfigManager(plugin);
+        this.mainConfigManager = new MainConfigManager(plugin);
+        this.playersConfigManager = new PlayersConfigManager(plugin,"players");
+        this.inventoryConfigManager = new InventoryConfigManager(plugin);
+    }
+
+    public void configure(){
+        this.kitsConfigManager.configure();
+        this.messagesConfigManager.configure();
+        this.mainConfigManager.configure();
+        if(!mainConfigManager.isMySQL()){
+            this.playersConfigManager.configure();
+        }
+        this.inventoryConfigManager.configure();
+    }
+
+    public KitsConfigManager getKitsConfigManager() {
+        return kitsConfigManager;
+    }
+
+    public MessagesConfigManager getMessagesConfigManager() {
+        return messagesConfigManager;
+    }
+
+    public MainConfigManager getMainConfigManager() {
+        return mainConfigManager;
+    }
+
+    public PlayersConfigManager getPlayersConfigManager() {
+        return playersConfigManager;
+    }
+
+    public InventoryConfigManager getInventoryConfigManager() {
+        return inventoryConfigManager;
+    }
+
+    public boolean reload(){
+        if(!messagesConfigManager.reloadConfig()){
+            return false;
+        }
+        if(!mainConfigManager.reloadConfig()){
+            return false;
+        }
+        if(!inventoryConfigManager.reloadConfig()){
+            return false;
+        }
+        kitsConfigManager.reloadConfigs();
+        if(plugin.getMySQLConnection() == null){
+            plugin.reloadPlayerDataSaveTask();
+        }
+
+        return true;
+    }
+}

src/main/java/pk/ajneb97/configs/CustomConfig.java

@@ -0,0 +1,112 @@
+package pk.ajneb97.configs;
+
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import pk.ajneb97.PlayerKits2;
+import java.io.*;
+
+public class CustomConfig {
+
+    private String fileName;
+    private FileConfiguration fileConfiguration = null;
+    private File file = null;
+    private String route;
+    private PlayerKits2 plugin;
+    private String folderName;
+    private boolean newFile;
+    private boolean isFirstTime;
+
+    public CustomConfig(String fileName, PlayerKits2 plugin, String folderName, boolean newFile){
+        this.fileName = fileName;
+        this.plugin = plugin;
+        this.newFile = newFile;
+        this.folderName = folderName;
+        this.isFirstTime = false;
+    }
+
+    public String getPath(){
+        return this.fileName;
+    }
+
+    public void registerConfig(){
+        if(folderName != null){
+            file = new File(plugin.getDataFolder() +File.separator + folderName,fileName);
+        }else{
+            file = new File(plugin.getDataFolder(), fileName);
+        }
+
+        route = file.getPath();
+
+        if(!file.exists()){
+            isFirstTime = true;
+            if(newFile) {
+                try {
+                    file.createNewFile();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }else {
+                if(folderName != null){
+                    plugin.saveResource(folderName+File.separator+fileName, false);
+                }else{
+                    plugin.saveResource(fileName, false);
+                }
+
+            }
+        }
+
+        fileConfiguration = new YamlConfiguration();
+        try {
+            fileConfiguration.load(file);
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (InvalidConfigurationException e) {
+            e.printStackTrace();
+        }
+    }
+    public void saveConfig() {
+        try {
+            fileConfiguration.save(file);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public FileConfiguration getConfig() {
+        if (fileConfiguration == null) {
+            reloadConfig();
+        }
+        return fileConfiguration;
+    }
+
+    public boolean reloadConfig() {
+        if (fileConfiguration == null) {
+            if(folderName != null){
+                file = new File(plugin.getDataFolder() +File.separator + folderName, fileName);
+            }else{
+                file = new File(plugin.getDataFolder(), fileName);
+            }
+
+        }
+        fileConfiguration = YamlConfiguration.loadConfiguration(file);
+
+        if(file != null) {
+            YamlConfiguration defConfig = YamlConfiguration.loadConfiguration(file);
+            fileConfiguration.setDefaults(defConfig);
+        }
+        return true;
+    }
+
+    public String getRoute() {
+        return route;
+    }
+
+    public boolean isFirstTime() {
+        return isFirstTime;
+    }
+
+    public void setFirstTime(boolean firstTime) {
+        isFirstTime = firstTime;
+    }
+}

src/main/java/pk/ajneb97/configs/InventoryConfigManager.java

@@ -0,0 +1,148 @@
+package pk.ajneb97.configs;
+
+import org.bukkit.configuration.file.FileConfiguration;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.KitItemManager;
+import pk.ajneb97.model.inventory.ItemKitInventory;
+import pk.ajneb97.model.inventory.KitInventory;
+import pk.ajneb97.model.item.KitItem;
+import pk.ajneb97.utils.OtherUtils;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+public class InventoryConfigManager {
+
+    private PlayerKits2 plugin;
+    private CustomConfig configFile;
+
+
+    public InventoryConfigManager(PlayerKits2 plugin){
+        this.plugin = plugin;
+        this.configFile = new CustomConfig("inventory.yml",plugin,null, false);
+        this.configFile.registerConfig();
+        if(this.configFile.isFirstTime() && OtherUtils.isLegacy()){
+            checkAndFix();
+        }
+    }
+
+    public void checkAndFix(){
+        FileConfiguration config = configFile.getConfig();
+        config.set("inventories.main_inventory.0;1;7;8;9;17;36;44;45;46;52;53.item.id","STAINED_GLASS_PANE:15");
+        config.set("inventories.premium_kits_inventory.0;1;7;8;9;17;36;44;45;46;52;53.item.id","STAINED_GLASS_PANE:4");
+        config.set("inventories.buy_requirements_inventory.10.item.id","STAINED_GLASS_PANE:14");
+        config.set("inventories.buy_requirements_inventory.16.item.id","STAINED_GLASS_PANE:5");
+        configFile.saveConfig();
+    }
+
+    public void configure(){
+        FileConfiguration config = configFile.getConfig();
+
+        ArrayList<KitInventory> inventories = new ArrayList<KitInventory>();
+        KitItemManager kitItemManager = plugin.getKitItemManager();
+        if(config.contains("inventories")) {
+            for(String key : config.getConfigurationSection("inventories").getKeys(false)) {
+                int slots = Integer.valueOf(config.getString("inventories."+key+".slots"));
+                String title = config.getString("inventories."+key+".title");
+
+                List<ItemKitInventory> items = new ArrayList<>();
+                for(String slotString : config.getConfigurationSection("inventories."+key).getKeys(false)) {
+                    if(!slotString.equals("slots") && !slotString.equals("title")) {
+                        String path = "inventories."+key+"."+slotString;
+                        KitItem item = null;
+                        if(config.contains(path+".item")){
+                            item = kitItemManager.getKitItemFromConfig(config, path+".item");
+                        }
+
+                        String openInventory = config.contains(path+".open_inventory") ?
+                                config.getString(path+".open_inventory") : null;
+
+                        List<String> commands = config.contains(path+".click_commands") ?
+                                config.getStringList(path+".click_commands") : null;
+
+                        String type = config.contains(path+".type") ?
+                                config.getString(path+".type") : null;
+
+                        ItemKitInventory itemCraft = new ItemKitInventory(slotString,item,openInventory,commands,type);
+                        items.add(itemCraft);
+                    }
+                }
+
+                KitInventory inv = new KitInventory(key,slots,title,items);
+                inventories.add(inv);
+            }
+        }
+
+        plugin.getInventoryManager().setInventories(inventories);
+    }
+
+    public void saveKitItemOnConfig(String inventoryName,int slot,String kitName){
+        FileConfiguration config = configFile.getConfig();
+        config.set("inventories."+inventoryName+"."+slot+".type","kit: "+kitName);
+
+        configFile.saveConfig();
+    }
+
+    public void save(){
+        FileConfiguration config = configFile.getConfig();
+        config.set("inventories",null);
+
+        KitItemManager kitItemManager = plugin.getKitItemManager();
+        for(KitInventory kitInventory : plugin.getInventoryManager().getInventories()){
+            String name = kitInventory.getName();
+            config.set("inventories."+name+".slots",kitInventory.getSlots());
+            config.set("inventories."+name+".title",kitInventory.getTitle());
+            for(ItemKitInventory item : kitInventory.getItems()){
+                String slotsString = item.getSlotsString();
+                String path = "inventories."+name+"."+slotsString;
+                if(item.getType() != null){
+                    config.set(path+".type",item.getType());
+                }
+                if(item.getItem() != null){
+                    kitItemManager.saveKitItemOnConfig(item.getItem(),config,path+".item");
+                }
+                if(item.getOpenInventory() != null){
+                    config.set(path+".open_inventory",item.getOpenInventory());
+                }
+                if(item.getCommands() != null && !item.getCommands().isEmpty()){
+                    config.set(path+".click_commands",item.getCommands());
+                }
+            }
+        }
+
+        configFile.saveConfig();
+    }
+
+    public boolean reloadConfig(){
+        if(!configFile.reloadConfig()){
+            return false;
+        }
+        configure();
+        return true;
+    }
+
+    public FileConfiguration getConfig(){
+        return configFile.getConfig();
+    }
+
+    public void checkUpdate(){
+        Path pathConfig = Paths.get(configFile.getRoute());
+        try{
+            String text = new String(Files.readAllBytes(pathConfig));
+            /*
+            if(!text.contains("register_commands:")){
+                List<String> commands = new ArrayList<>();
+                getConfig().set("Config.register_commands", commands);
+                saveConfig();
+            }
+            */
+        }catch(IOException e){
+            e.printStackTrace();
+        }
+    }
+
+}

src/main/java/pk/ajneb97/configs/KitsConfigManager.java

@@ -0,0 +1,298 @@
+package pk.ajneb97.configs;
+
+import org.bukkit.configuration.file.FileConfiguration;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.KitItemManager;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.model.KitAction;
+import pk.ajneb97.model.KitRequirements;
+import pk.ajneb97.model.item.KitItem;
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class KitsConfigManager {
+    private ArrayList<CustomConfig> configFiles;
+    private String folderName;
+    private PlayerKits2 plugin;
+
+    public KitsConfigManager(PlayerKits2 plugin, String folderName){
+        this.plugin = plugin;
+        this.folderName = folderName;
+        this.configFiles = new ArrayList<>();
+    }
+
+    public void configure() {
+        createFolder();
+        reloadConfigs();
+    }
+
+    public void reloadConfigs(){
+        this.configFiles = new ArrayList<>();
+        registerConfigFiles();
+        loadConfigs();
+    }
+
+    public void createFolder(){
+        File folder;
+        try {
+            folder = new File(plugin.getDataFolder() + File.separator + folderName);
+            if(!folder.exists()){
+                folder.mkdirs();
+                createDefaultConfigs();
+            }
+        } catch(SecurityException e) {
+            folder = null;
+        }
+    }
+
+    public void createDefaultConfigs(){
+        new CustomConfig("diamond.yml",plugin,folderName,false).registerConfig();
+        new CustomConfig("iron.yml",plugin,folderName,false).registerConfig();
+        new CustomConfig("food.yml",plugin,folderName,false).registerConfig();
+    }
+
+    public void saveConfigFiles() {
+        for(int i=0;i<configFiles.size();i++) {
+            configFiles.get(i).saveConfig();
+        }
+    }
+
+    public void registerConfigFiles(){
+        String path = plugin.getDataFolder() + File.separator + folderName;
+        File folder = new File(path);
+        File[] listOfFiles = folder.listFiles();
+        for (int i=0;i<listOfFiles.length;i++) {
+            if(listOfFiles[i].isFile()) {
+                String pathName = listOfFiles[i].getName();
+                CustomConfig config = new CustomConfig(pathName, plugin, folderName, true);
+                config.registerConfig();
+                configFiles.add(config);
+            }
+        }
+    }
+
+    public ArrayList<CustomConfig> getConfigs(){
+        return this.configFiles;
+    }
+
+    public boolean fileAlreadyRegistered(String pathName) {
+        for(int i=0;i<configFiles.size();i++) {
+            if(configFiles.get(i).getPath().equals(pathName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public CustomConfig getConfigFile(String pathName) {
+        for(int i=0;i<configFiles.size();i++) {
+            if(configFiles.get(i).getPath().equals(pathName)) {
+                return configFiles.get(i);
+            }
+        }
+        return null;
+    }
+
+    public boolean registerConfigFile(String pathName) {
+        if(!fileAlreadyRegistered(pathName)) {
+            CustomConfig config = new CustomConfig(pathName, plugin, folderName, true);
+            config.registerConfig();
+            configFiles.add(config);
+            return true;
+        }else {
+            return false;
+        }
+    }
+
+    public void removeConfigKit(String path) {
+        for(int i=0;i<configFiles.size();i++) {
+            if(configFiles.get(i).getPath().equals(path)) {
+                configFiles.remove(i);
+            }
+        }
+    }
+
+    public void loadConfigs(){
+        ArrayList<Kit> kits = new ArrayList<Kit>();
+        for(CustomConfig configFile : configFiles){
+            FileConfiguration config = configFile.getConfig();
+
+            String name = configFile.getPath().replace(".yml","");
+            Kit kit = getKitFromConfig(config,plugin,name,"");
+            kits.add(kit);
+        }
+
+        plugin.getKitsManager().setKits(kits);
+    }
+
+    public void saveConfigs(){
+
+    }
+
+    public void saveConfig(Kit kit){
+        String kitName = kit.getName();
+        CustomConfig kitConfig = getConfigFile(kitName+".yml");
+        if(kitConfig == null) {
+            registerConfigFile(kitName+".yml");
+            kitConfig = getConfigFile(kitName+".yml");
+        }
+
+        FileConfiguration config = kitConfig.getConfig();
+
+        config.set("cooldown",kit.getCooldown());
+        config.set("one_time",kit.isOneTime());
+        config.set("auto_armor",kit.isAutoArmor());
+        config.set("permission_required",kit.isPermissionRequired());
+
+        KitItemManager kitItemManager = plugin.getKitItemManager();
+        int currentPos = 1;
+        config.set("items",null);
+        for(KitItem kitItem : kit.getItems()){
+            kitItemManager.saveKitItemOnConfig(kitItem,config,"items."+currentPos);
+            currentPos++;
+        }
+
+
+        config.set("actions",null);
+        saveActions(kit.getClaimActions(),"claim",config,kitItemManager);
+        saveActions(kit.getErrorActions(),"error",config,kitItemManager);
+
+        config.set("display.default",null);
+        if(kit.getDisplayItemDefault() != null){
+            kitItemManager.saveKitItemOnConfig(kit.getDisplayItemDefault(),config,"display.default");
+        }
+        config.set("display.no_permission",null);
+        if(kit.getDisplayItemNoPermission() != null){
+            kitItemManager.saveKitItemOnConfig(kit.getDisplayItemNoPermission(),config,"display.no_permission");
+        }
+        config.set("display.cooldown",null);
+        if(kit.getDisplayItemCooldown() != null){
+            kitItemManager.saveKitItemOnConfig(kit.getDisplayItemCooldown(),config,"display.cooldown");
+        }
+        config.set("display.one_time",null);
+        if(kit.getDisplayItemOneTime() != null){
+            kitItemManager.saveKitItemOnConfig(kit.getDisplayItemOneTime(),config,"display.one_time");
+        }
+        config.set("display.one_time_requirements",null);
+        if(kit.getDisplayItemOneTimeRequirements() != null){
+            kitItemManager.saveKitItemOnConfig(kit.getDisplayItemOneTimeRequirements(),config,"display.one_time_requirements");
+        }
+
+        KitRequirements requirements = kit.getRequirements();
+        if(requirements != null){
+            config.set("requirements.one_time_requirements",requirements.isOneTimeRequirements());
+            if(requirements.getExtraRequirements() != null){
+                config.set("requirements.extra_requirements",requirements.getExtraRequirements());
+            }
+            config.set("requirements.message",requirements.getMessage());
+            if(requirements.getActionsOnBuy() != null){
+                config.set("requirements.actions_on_buy",requirements.getActionsOnBuy());
+            }
+            if(requirements.getPrice() != 0){
+                config.set("requirements.price",requirements.getPrice());
+            }
+        }
+
+        kitConfig.saveConfig();
+    }
+
+    public void saveActions(ArrayList<KitAction> kitActions,String actionType,FileConfiguration config,KitItemManager kitItemManager){
+        int currentPos = 1;
+        for(KitAction kitAction : kitActions){
+            String path = "actions."+actionType+"."+currentPos;
+            config.set(path+".action",kitAction.getAction());
+            config.set(path+".execute_before_items",kitAction.isExecuteBeforeItems());
+            if(kitAction.getDisplayItem() != null){
+                kitItemManager.saveKitItemOnConfig(kitAction.getDisplayItem(),config,path+".display_item");
+            }
+
+            currentPos++;
+        }
+    }
+
+    public void removeKitFile(String kitName){
+        CustomConfig kitConfig = getConfigFile(kitName+".yml");
+        if(kitConfig == null){
+            return;
+        }
+
+        File file = new File(plugin.getDataFolder()+File.separator+folderName,kitConfig.getPath());
+        file.delete();
+
+        removeConfigKit(kitConfig.getPath());
+    }
+
+    // mainPath must include a "." at the end
+    public static Kit getKitFromConfig(FileConfiguration config, PlayerKits2 plugin, String name, String mainPath){
+        KitItemManager kitItemManager = plugin.getKitItemManager();
+        int cooldown = config.contains(mainPath+"cooldown") ? config.getInt(mainPath+"cooldown") : 0;
+        boolean permissionRequired = config.contains(mainPath+"permission_required") ? config.getBoolean(mainPath+"permission_required") : false;
+        boolean autoArmor = config.contains(mainPath+"auto_armor") ? config.getBoolean(mainPath+"auto_armor") : false;
+        boolean oneTime = config.contains(mainPath+"one_time") ? config.getBoolean(mainPath+"one_time") : false;
+
+        ArrayList<KitItem> items = new ArrayList<KitItem>();
+        if(config.contains(mainPath+"items")){
+            for(String key : config.getConfigurationSection(mainPath+"items").getKeys(false)){
+                KitItem item = kitItemManager.getKitItemFromConfig(config,mainPath+"items."+key);
+                items.add(item);
+            }
+        }
+        ArrayList<KitAction> claimActions = getActions(config,"claim",mainPath,kitItemManager);
+        ArrayList<KitAction> errorActions = getActions(config,"error",mainPath,kitItemManager);
+
+        KitItem displayItemDefault = kitItemManager.getKitItemFromConfig(config,mainPath+"display.default");
+        KitItem displayItemNoPermission = config.contains(mainPath+"display.no_permission") ?
+                kitItemManager.getKitItemFromConfig(config,mainPath+"display.no_permission") : null;
+        KitItem displayItemCooldown = config.contains(mainPath+"display.cooldown") ?
+                kitItemManager.getKitItemFromConfig(config,mainPath+"display.cooldown") : null;
+        KitItem displayItemOneTime = config.contains(mainPath+"display.one_time") ?
+                kitItemManager.getKitItemFromConfig(config,mainPath+"display.one_time") : null;
+        KitItem displayItemOneTimeRequirements = config.contains(mainPath+"display.one_time_requirements") ?
+                kitItemManager.getKitItemFromConfig(config,mainPath+"display.one_time_requirements") : null;
+
+        KitRequirements kitRequirements = null;
+        if(config.contains("requirements")){
+            boolean oneTimeRequirements = config.getBoolean("requirements.one_time_requirements");
+            List<String> extraRequirements = config.getStringList("requirements.extra_requirements");
+            List<String> message = config.getStringList("requirements.message");
+            List<String> actionsOnBuy = config.getStringList("requirements.actions_on_buy");
+            double price = config.contains("requirements.price") ? config.getDouble("requirements.price") : 0;
+            kitRequirements = new KitRequirements(oneTimeRequirements,extraRequirements,message,actionsOnBuy,price);
+        }
+
+
+        Kit kit = new Kit(name);
+        kit.setCooldown(cooldown);
+
+        kit.setAutoArmor(autoArmor);
+        kit.setOneTime(oneTime);
+        kit.setPermissionRequired(permissionRequired);
+        kit.setItems(items);
+        kit.setClaimActions(claimActions);
+        kit.setErrorActions(errorActions);
+        kit.setDisplayItemDefault(displayItemDefault);
+        kit.setDisplayItemNoPermission(displayItemNoPermission);
+        kit.setDisplayItemCooldown(displayItemCooldown);
+        kit.setDisplayItemOneTime(displayItemOneTime);
+        kit.setDisplayItemOneTimeRequirements(displayItemOneTimeRequirements);
+        kit.setRequirements(kitRequirements);
+
+        return kit;
+    }
+
+    public static ArrayList<KitAction> getActions(FileConfiguration config,String actionType,String mainPath,KitItemManager kitItemManager){
+        ArrayList<KitAction> actions = new ArrayList<>();
+        if(config.contains(mainPath+"actions."+actionType)){
+            for(String key : config.getConfigurationSection(mainPath+"actions."+actionType).getKeys(false)){
+                String path = mainPath+"actions."+actionType+"."+key;
+                String action = config.getString(path+".action");
+                boolean executeBeforeItem = config.contains("execute_before_items") ? config.getBoolean("execute_before_items") : false;
+                KitItem item = config.contains(path+".display_item") ? kitItemManager.getKitItemFromConfig(config,path+".display_item") : null;
+
+                actions.add(new KitAction(action,item,executeBeforeItem));
+            }
+        }
+        return actions;
+    }
+}

src/main/java/pk/ajneb97/configs/MainConfigManager.java

@@ -0,0 +1,98 @@
+package pk.ajneb97.configs;
+
+import org.bukkit.configuration.file.FileConfiguration;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.model.Kit;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class MainConfigManager {
+
+    private PlayerKits2 plugin;
+    private CustomConfig configFile;
+
+    //Options
+    private Kit newKitDefault;
+    private boolean kitPreview;
+    private boolean closeInventoryOnClaim;
+    private boolean kitPreviewRequiresKitPermission;
+    private String firstJoinKit;
+    private String newKitDefaultInventory;
+    private boolean isMySQL;
+
+    public MainConfigManager(PlayerKits2 plugin){
+        this.plugin = plugin;
+        this.configFile = new CustomConfig("config.yml",plugin,null, false);
+        this.configFile.registerConfig();
+    }
+
+    public void configure(){
+        FileConfiguration config = configFile.getConfig();
+        newKitDefault = KitsConfigManager.getKitFromConfig(config,plugin,null,"new_kit_default_values.");
+        kitPreview = config.getBoolean("kit_preview");
+        closeInventoryOnClaim = config.getBoolean("close_inventory_on_claim");
+        kitPreviewRequiresKitPermission = config.getBoolean("kit_preview_requires_kit_permission");
+        firstJoinKit = config.getString("first_join_kit");
+        newKitDefaultInventory = config.getString("new_kit_default_inventory");
+        isMySQL = config.getBoolean("mysql_database.enabled");
+    }
+
+    public boolean reloadConfig(){
+        if(!configFile.reloadConfig()){
+            return false;
+        }
+        configure();
+        return true;
+    }
+
+    public FileConfiguration getConfig(){
+        return configFile.getConfig();
+    }
+
+    public void checkUpdate(){
+        Path pathConfig = Paths.get(configFile.getRoute());
+        try{
+            String text = new String(Files.readAllBytes(pathConfig));
+            /*
+            if(!text.contains("register_commands:")){
+                List<String> commands = new ArrayList<>();
+                getConfig().set("Config.register_commands", commands);
+                saveConfig();
+            }
+            */
+        }catch(IOException e){
+            e.printStackTrace();
+        }
+    }
+
+    public Kit getNewKitDefault() {
+        return newKitDefault;
+    }
+
+    public boolean isKitPreview() {
+        return kitPreview;
+    }
+
+    public boolean isCloseInventoryOnClaim() {
+        return closeInventoryOnClaim;
+    }
+
+    public boolean isKitPreviewRequiresKitPermission() {
+        return kitPreviewRequiresKitPermission;
+    }
+
+    public String getFirstJoinKit() {
+        return firstJoinKit;
+    }
+
+    public String getNewKitDefaultInventory() {
+        return newKitDefaultInventory;
+    }
+
+    public boolean isMySQL() {
+        return isMySQL;
+    }
+}

src/main/java/pk/ajneb97/configs/MessagesConfigManager.java

@@ -0,0 +1,68 @@
+package pk.ajneb97.configs;
+
+import org.bukkit.configuration.file.FileConfiguration;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.MessagesManager;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class MessagesConfigManager {
+
+    private PlayerKits2 plugin;
+    private CustomConfig configFile;
+
+    public MessagesConfigManager(PlayerKits2 plugin){
+        this.plugin = plugin;
+        this.configFile = new CustomConfig("messages.yml",plugin,null, false);
+        this.configFile.registerConfig();
+
+    }
+
+    public void configure(){
+        FileConfiguration config = configFile.getConfig();
+
+        //Configure messages
+        MessagesManager msgManager = new MessagesManager();
+        msgManager.setTimeSeconds(config.getString("seconds"));
+        msgManager.setTimeMinutes(config.getString("minutes"));
+        msgManager.setTimeHours(config.getString("hours"));
+        msgManager.setTimeDays(config.getString("days"));
+        msgManager.setPrefix(config.getString("prefix"));
+        msgManager.setRequirementsMessageStatusSymbolTrue(config.getString("requirementsMessageStatusSymbolTrue"));
+        msgManager.setRequirementsMessageStatusSymbolFalse(config.getString("requirementsMessageStatusSymbolFalse"));
+        msgManager.setCooldownPlaceholderReady(config.getString("cooldownPlaceholderReady"));
+
+        this.plugin.setMessagesManager(msgManager);
+    }
+
+    public boolean reloadConfig(){
+        if(!configFile.reloadConfig()){
+            return false;
+        }
+        configure();
+        return true;
+    }
+
+    public FileConfiguration getConfig(){
+        return configFile.getConfig();
+    }
+
+    public void checkUpdate(){
+        Path pathConfig = Paths.get(configFile.getRoute());
+        try{
+            String text = new String(Files.readAllBytes(pathConfig));
+            /*
+            if(!text.contains("register_commands:")){
+                List<String> commands = new ArrayList<>();
+                getConfig().set("Config.register_commands", commands);
+                saveConfig();
+            }
+            */
+        }catch(IOException e){
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/pk/ajneb97/configs/PlayersConfigManager.java

@@ -0,0 +1,157 @@
+package pk.ajneb97.configs;
+
+import org.bukkit.configuration.file.FileConfiguration;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.model.PlayerData;
+import pk.ajneb97.model.PlayerDataKit;
+
+import java.io.File;
+import java.util.ArrayList;
+
+public class PlayersConfigManager {
+    private ArrayList<CustomConfig> configFiles;
+    private String folderName;
+    private PlayerKits2 plugin;
+
+    public PlayersConfigManager(PlayerKits2 plugin, String folderName){
+        this.plugin = plugin;
+        this.folderName = folderName;
+        this.configFiles = new ArrayList<>();
+    }
+
+    public void configure() {
+        createFolder();
+        reloadConfigs();
+    }
+
+    public void reloadConfigs(){
+        this.configFiles = new ArrayList<>();
+        registerConfigFiles();
+        loadConfigs();
+    }
+
+    public void createFolder(){
+        File folder;
+        try {
+            folder = new File(plugin.getDataFolder() + File.separator + folderName);
+            if(!folder.exists()){
+                folder.mkdirs();
+            }
+        } catch(SecurityException e) {
+            folder = null;
+        }
+    }
+
+    public void saveConfigFiles() {
+        for(int i=0;i<configFiles.size();i++) {
+            configFiles.get(i).saveConfig();
+        }
+    }
+
+    public void registerConfigFiles(){
+        String path = plugin.getDataFolder() + File.separator + folderName;
+        File folder = new File(path);
+        File[] listOfFiles = folder.listFiles();
+        for (int i=0;i<listOfFiles.length;i++) {
+            if(listOfFiles[i].isFile()) {
+                String pathName = listOfFiles[i].getName();
+                CustomConfig config = new CustomConfig(pathName, plugin, folderName, true);
+                config.registerConfig();
+                configFiles.add(config);
+            }
+        }
+    }
+
+    public ArrayList<CustomConfig> getConfigs(){
+        return this.configFiles;
+    }
+
+    public boolean fileAlreadyRegistered(String pathName) {
+        for(int i=0;i<configFiles.size();i++) {
+            if(configFiles.get(i).getPath().equals(pathName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public CustomConfig getConfigFile(String pathName) {
+        for(int i=0;i<configFiles.size();i++) {
+            if(configFiles.get(i).getPath().equals(pathName)) {
+                return configFiles.get(i);
+            }
+        }
+        return null;
+    }
+
+    public boolean registerConfigFile(String pathName) {
+        if(!fileAlreadyRegistered(pathName)) {
+            CustomConfig config = new CustomConfig(pathName, plugin, folderName, true);
+            config.registerConfig();
+            configFiles.add(config);
+            return true;
+        }else {
+            return false;
+        }
+    }
+
+    public void loadConfigs(){
+        ArrayList<PlayerData> players = new ArrayList<>();
+
+        for(CustomConfig configFile : configFiles) {
+            FileConfiguration config = configFile.getConfig();
+
+            String uuid = configFile.getPath().replace(".yml", "");
+            String name = config.getString("name");
+            ArrayList<PlayerDataKit> playerDataKits = new ArrayList<>();
+
+            if(config.contains("kits")){
+                for(String key : config.getConfigurationSection("kits").getKeys(false)){
+                    long cooldown = config.getLong("kits."+key+".cooldown");
+                    boolean oneTime = config.getBoolean("kits."+key+".one_time");
+                    boolean bought = config.getBoolean("kits."+key+".bought");
+
+                    PlayerDataKit playerDataKit = new PlayerDataKit(key);
+                    playerDataKit.setCooldown(cooldown);
+                    playerDataKit.setOneTime(oneTime);
+                    playerDataKit.setBought(bought);
+
+                    playerDataKits.add(playerDataKit);
+                }
+            }
+
+            PlayerData playerData = new PlayerData(name,uuid);
+            playerData.setKits(playerDataKits);
+
+            players.add(playerData);
+        }
+
+        plugin.getPlayerDataManager().setPlayers(players);
+    }
+
+    public void saveConfigs(){
+        ArrayList<PlayerData> players = plugin.getPlayerDataManager().getPlayers();
+        for(PlayerData playerData : players) {
+            String playerName = playerData.getName();
+            CustomConfig playerConfig = getConfigFile(playerData.getUuid()+".yml");
+            if(playerConfig == null) {
+                registerConfigFile(playerData.getUuid()+".yml");
+                playerConfig = getConfigFile(playerData.getUuid()+".yml");
+            }
+            FileConfiguration config = playerConfig.getConfig();
+
+            config.set("name", playerName);
+            config.set("kits",null);
+
+            for(PlayerDataKit playerDataKit : playerData.getKits()){
+                String kitName = playerDataKit.getName();
+                config.set("kits."+kitName+".cooldown",playerDataKit.getCooldown());
+                config.set("kits."+kitName+".one_time",playerDataKit.isOneTime());
+                config.set("kits."+kitName+".bought",playerDataKit.isBought());
+            }
+        }
+
+        saveConfigFiles();
+    }
+
+}

src/main/java/pk/ajneb97/database/HikariConnection.java

@@ -0,0 +1,32 @@
+package pk.ajneb97.database;
+
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+
+public class HikariConnection {
+
+    private HikariDataSource hikari;
+
+    public HikariConnection(String ip, int port, String database, String username, String password) {
+        HikariConfig config = new HikariConfig();
+        config.setJdbcUrl("jdbc:mysql://" + ip + ":" + port + "/" + database);
+        config.setUsername(username);
+        config.setPassword(password);
+        config.addDataSourceProperty("autoReconnect", "true");
+        config.addDataSourceProperty("leakDetectionThreshold", "true");
+        config.addDataSourceProperty("verifyServerCertificate", "false");
+        config.addDataSourceProperty("useSSL", "false");
+        config.setConnectionTimeout(5000);
+        hikari = new HikariDataSource(config);
+    }
+
+    public HikariDataSource getHikari() {
+        return this.hikari;
+    }
+
+    public void disable() {
+        if(hikari != null) {
+            hikari.close();
+        }
+    }
+}

src/main/java/pk/ajneb97/database/MySQLConnection.java

@@ -0,0 +1,286 @@
+package pk.ajneb97.database;
+
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.scheduler.BukkitRunnable;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.MessagesManager;
+import pk.ajneb97.model.PlayerData;
+import pk.ajneb97.model.PlayerDataKit;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Set;
+
+public class MySQLConnection {
+
+    private PlayerKits2 plugin;
+    private HikariConnection connection;
+    private String host;
+    private String database;
+    private String username;
+    private String password;
+    private int port;
+
+    public MySQLConnection(PlayerKits2 plugin){
+        this.plugin = plugin;
+    }
+
+    public void setupMySql(){
+        FileConfiguration config = plugin.getConfigsManager().getMainConfigManager().getConfig();
+        try {
+            host = config.getString("mysql_database.host");
+            port = Integer.valueOf(config.getString("mysql_database.port"));
+            database = config.getString("mysql_database.database");
+            username = config.getString("mysql_database.username");
+            password = config.getString("mysql_database.password");
+            connection = new HikariConnection(host,port,database,username,password);
+            connection.getHikari().getConnection();
+            createTables();
+            loadData();
+            Bukkit.getConsoleSender().sendMessage(MessagesManager.getColoredMessage(plugin.prefix+" &aSuccessfully connected to the Database."));
+        }catch(Exception e) {
+            Bukkit.getConsoleSender().sendMessage(MessagesManager.getColoredMessage(plugin.prefix+" &cError while connecting to the Database."));
+        }
+    }
+
+
+    public String getDatabase() {
+        return this.database;
+    }
+
+    public Connection getConnection() {
+        try {
+            return connection.getHikari().getConnection();
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public void loadData(){
+        ArrayList<PlayerData> players = new ArrayList<>();
+        try(Connection connection = getConnection()){
+            PreparedStatement statement = connection.prepareStatement(
+                    "SELECT playerkits_players.UUID, playerkits_players.PLAYER_NAME, " +
+                            "playerkits_players_kits.NAME, " +
+                            "playerkits_players_kits.COOLDOWN, " +
+                            "playerkits_players_kits.ONE_TIME, " +
+                            "playerkits_players_kits.BOUGHT " +
+                            "FROM playerkits_players LEFT JOIN playerkits_players_kits " +
+                            "ON playerkits_players.UUID = playerkits_players_kits.UUID");
+
+            ResultSet result = statement.executeQuery();
+
+            Set<String> existingUUIDs = new HashSet<>();
+            while(result.next()){
+                String uuid = result.getString("UUID");
+                String playerName = result.getString("PLAYER_NAME");
+                String kitName = result.getString("NAME");
+                long cooldown = result.getLong("COOLDOWN");
+                boolean oneTime = result.getBoolean("ONE_TIME");
+                boolean bought = result.getBoolean("BOUGHT");
+
+                PlayerData currentPlayer;
+                if(!existingUUIDs.contains(uuid)){
+                    //Create and add it
+                    currentPlayer = new PlayerData(playerName,uuid);
+                    players.add(currentPlayer);
+                    existingUUIDs.add(uuid);
+                }else{
+                    currentPlayer = players.stream()
+                            .filter(p -> p.getUuid().equals(uuid))
+                            .findFirst()
+                            .orElse(null);
+                }
+
+                if(kitName != null){
+                    PlayerDataKit playerDataKit = new PlayerDataKit(kitName);
+                    playerDataKit.setCooldown(cooldown);
+                    playerDataKit.setOneTime(oneTime);
+                    playerDataKit.setBought(bought);
+                    currentPlayer.addKit(playerDataKit);
+                }
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+
+        plugin.getPlayerDataManager().setPlayers(players);
+    }
+
+    public void createTables() {
+        try(Connection connection = getConnection()){
+            PreparedStatement statement1 = connection.prepareStatement(
+                    "CREATE TABLE IF NOT EXISTS playerkits_players" +
+                    " (UUID varchar(200) NOT NULL, " +
+                    " PLAYER_NAME varchar(50), " +
+                    " PRIMARY KEY ( UUID ))"
+            );
+            statement1.executeUpdate();
+            PreparedStatement statement2 = connection.prepareStatement(
+                    "CREATE TABLE IF NOT EXISTS playerkits_players_kits" +
+                    " (ID int NOT NULL AUTO_INCREMENT, " +
+                    " UUID varchar(200) NOT NULL, " +
+                    " NAME varchar(100), " +
+                    " COOLDOWN BIGINT, " +
+                    " ONE_TIME BOOLEAN, " +
+                    " BOUGHT BOOLEAN, " +
+                    " PRIMARY KEY ( ID ), " +
+                    " FOREIGN KEY (UUID) REFERENCES playerkits_players(UUID))");
+            statement2.executeUpdate();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void getPlayer(String uuid,PlayerCallback callback){
+        new BukkitRunnable(){
+            @Override
+            public void run() {
+                PlayerData player = null;
+                try(Connection connection = getConnection()){
+                    PreparedStatement statement = connection.prepareStatement(
+                            "SELECT playerkits_players.UUID, playerkits_players.PLAYER_NAME, " +
+                                    "playerkits_players_kits.NAME, " +
+                                    "playerkits_players_kits.COOLDOWN, " +
+                                    "playerkits_players_kits.ONE_TIME, " +
+                                    "playerkits_players_kits.BOUGHT " +
+                                    "FROM playerkits_players LEFT JOIN playerkits_players_kits " +
+                                    "ON playerkits_players.UUID = playerkits_players_kits.UUID " +
+                                    "WHERE playerkits_players.UUID = ?");
+
+                    statement.setString(1, uuid);
+                    ResultSet result = statement.executeQuery();
+
+                    boolean firstFind = true;
+                    while(result.next()){
+                        String playerName = result.getString("PLAYER_NAME");
+                        String kitName = result.getString("NAME");
+                        long cooldown = result.getLong("COOLDOWN");
+                        boolean oneTime = result.getBoolean("ONE_TIME");
+                        boolean bought = result.getBoolean("BOUGHT");
+                        if(firstFind){
+                            firstFind = false;
+                            player = new PlayerData(playerName,uuid);
+                        }
+                        if(kitName != null){
+                            PlayerDataKit playerDataKit = new PlayerDataKit(kitName);
+                            playerDataKit.setCooldown(cooldown);
+                            playerDataKit.setOneTime(oneTime);
+                            playerDataKit.setBought(bought);
+                            player.addKit(playerDataKit);
+                        }
+                    }
+
+                    PlayerData finalPlayer = player;
+                    new BukkitRunnable(){
+                        @Override
+                        public void run() {
+                            callback.onDone(finalPlayer);
+                        }
+                    }.runTask(plugin);
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            }
+        }.runTaskAsynchronously(plugin);
+    }
+
+    public void createPlayer(PlayerData player){
+        new BukkitRunnable(){
+            @Override
+            public void run() {
+                try(Connection connection = getConnection()){
+                    PreparedStatement statement = connection.prepareStatement(
+                            "INSERT INTO playerkits_players " +
+                                    "(UUID, PLAYER_NAME) VALUE (?,?)");
+
+                    statement.setString(1, player.getUuid());
+                    statement.setString(2, player.getName());
+                    statement.executeUpdate();
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            }
+        }.runTaskAsynchronously(plugin);
+    }
+
+    public void updatePlayerName(PlayerData player){
+        new BukkitRunnable(){
+            @Override
+            public void run() {
+                try(Connection connection = getConnection()){
+                    PreparedStatement statement = connection.prepareStatement(
+                            "UPDATE playerkits_players SET " +
+                                    "PLAYER_NAME=? WHERE UUID=?");
+
+                    statement.setString(1, player.getName());
+                    statement.setString(2, player.getUuid());
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            }
+        }.runTaskAsynchronously(plugin);
+    }
+
+    public void updateKit(PlayerData player,PlayerDataKit kit,boolean mustCreate){
+        new BukkitRunnable(){
+            @Override
+            public void run() {
+                try(Connection connection = getConnection()){
+                    PreparedStatement statement = null;
+                    if(mustCreate){
+                        // Insert
+                        statement = connection.prepareStatement(
+                                "INSERT INTO playerkits_players_kits " +
+                                        "(UUID, NAME, COOLDOWN, ONE_TIME, BOUGHT) VALUE (?,?,?,?,?)");
+
+                        statement.setString(1, player.getUuid());
+                        statement.setString(2, kit.getName());
+                        statement.setLong(3, kit.getCooldown());
+                        statement.setBoolean(4, kit.isOneTime());
+                        statement.setBoolean(5, kit.isBought());
+                    }else{
+                        // Update
+                        statement = connection.prepareStatement(
+                                "UPDATE playerkits_players_kits SET " +
+                                        "COOLDOWN=?, ONE_TIME=?, BOUGHT=? WHERE UUID=? AND NAME=?");
+
+                        statement.setLong(1, kit.getCooldown());
+                        statement.setBoolean(2, kit.isOneTime());
+                        statement.setBoolean(3, kit.isBought());
+                        statement.setString(4, player.getUuid());
+                        statement.setString(5, kit.getName());
+                    }
+                    statement.executeUpdate();
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            }
+        }.runTaskAsynchronously(plugin);
+    }
+
+    public void resetKit(String uuid,String kitName){
+        new BukkitRunnable(){
+            @Override
+            public void run() {
+                try(Connection connection = getConnection()){
+                    PreparedStatement statement = connection.prepareStatement(
+                            "DELETE FROM playerkits_players_kits " +
+                                    "WHERE UUID=? AND NAME=?");
+
+                    statement.setString(1, uuid);
+                    statement.setString(2, kitName);
+                    statement.executeUpdate();
+                } catch (SQLException e) {
+                    e.printStackTrace();
+                }
+            }
+        }.runTaskAsynchronously(plugin);
+    }
+}

src/main/java/pk/ajneb97/database/PlayerCallback.java

@@ -0,0 +1,8 @@
+package pk.ajneb97.database;
+
+import pk.ajneb97.model.PlayerData;
+
+public interface PlayerCallback {
+
+    void onDone(PlayerData player);
+}

src/main/java/pk/ajneb97/libs/actionbar/ActionBarAPI.java

@@ -0,0 +1,103 @@
+package pk.ajneb97.libs.actionbar;
+
+import net.md_5.bungee.api.ChatMessageType;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.MessagesManager;
+import pk.ajneb97.utils.OtherUtils;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+public class ActionBarAPI
+{
+
+
+    public static void sendActionBar(Player player, String message) {
+	  if(OtherUtils.isNew()) {
+		  player.spigot().sendMessage(ChatMessageType.ACTION_BAR, TextComponent.fromLegacyText(MessagesManager.getColoredMessage(message)));
+		  return;
+	  }
+      message = MessagesManager.getColoredMessage(message);
+	  boolean useOldMethods = false;
+	  String nmsver = Bukkit.getServer().getClass().getPackage().getName();
+      nmsver = nmsver.substring(nmsver.lastIndexOf(".") + 1);
+      if ((nmsver.equalsIgnoreCase("v1_8_R1")) || (nmsver.startsWith("v1_7_"))) {
+          useOldMethods = true;
+      }
+      if (!player.isOnline()) {
+          return; // Player may have logged out
+      }
+
+      try {
+          Class<?> craftPlayerClass = Class.forName("org.bukkit.craftbukkit." + nmsver + ".entity.CraftPlayer");
+          Object craftPlayer = craftPlayerClass.cast(player);
+          Object packet;
+          Class<?> packetPlayOutChatClass = Class.forName("net.minecraft.server." + nmsver + ".PacketPlayOutChat");
+          Class<?> packetClass = Class.forName("net.minecraft.server." + nmsver + ".Packet");
+          if (useOldMethods) {
+              Class<?> chatSerializerClass = Class.forName("net.minecraft.server." + nmsver + ".ChatSerializer");
+              Class<?> iChatBaseComponentClass = Class.forName("net.minecraft.server." + nmsver + ".IChatBaseComponent");
+              Method m3 = chatSerializerClass.getDeclaredMethod("a", String.class);
+              Object cbc = iChatBaseComponentClass.cast(m3.invoke(chatSerializerClass, "{\"text\": \"" + message + "\"}"));
+              packet = packetPlayOutChatClass.getConstructor(new Class<?>[]{iChatBaseComponentClass, byte.class}).newInstance(cbc, (byte) 2);
+          } else {
+              Class<?> chatComponentTextClass = Class.forName("net.minecraft.server." + nmsver + ".ChatComponentText");
+              Class<?> iChatBaseComponentClass = Class.forName("net.minecraft.server." + nmsver + ".IChatBaseComponent");
+              try {
+
+                  Class<?> chatMessageTypeClass = Class.forName("net.minecraft.server." + nmsver + ".ChatMessageType");
+                  Object[] chatMessageTypes = chatMessageTypeClass.getEnumConstants();
+                  Object chatMessageType = null;
+                  for (Object obj : chatMessageTypes) {
+                      if (obj.toString().equals("GAME_INFO")) {
+                          chatMessageType = obj;
+                      }
+                  }
+                  Object chatCompontentText = chatComponentTextClass.getConstructor(new Class<?>[]{String.class}).newInstance(message);
+                  packet = packetPlayOutChatClass.getConstructor(new Class<?>[]{iChatBaseComponentClass, chatMessageTypeClass}).newInstance(chatCompontentText, chatMessageType);
+              } catch (ClassNotFoundException cnfe) {
+                  Object chatCompontentText = chatComponentTextClass.getConstructor(new Class<?>[]{String.class}).newInstance(message);
+                  packet = packetPlayOutChatClass.getConstructor(new Class<?>[]{iChatBaseComponentClass, byte.class}).newInstance(chatCompontentText, (byte) 2);
+              }
+          }
+          Method craftPlayerHandleMethod = craftPlayerClass.getDeclaredMethod("getHandle");
+          Object craftPlayerHandle = craftPlayerHandleMethod.invoke(craftPlayer);
+          Field playerConnectionField = craftPlayerHandle.getClass().getDeclaredField("playerConnection");
+          Object playerConnection = playerConnectionField.get(craftPlayerHandle);
+          Method sendPacketMethod = playerConnection.getClass().getDeclaredMethod("sendPacket", packetClass);
+          sendPacketMethod.invoke(playerConnection, packet);
+      } catch (Exception e) {
+          e.printStackTrace();
+      }
+    }
+  
+  public static void sendActionBar(final Player player, final String message, int duration, PlayerKits2 plugin) {
+	  sendActionBar(player, message);
+	  
+      if (duration > 0) {
+          // Sends empty message at the end of the duration. Allows messages shorter than 3 seconds, ensures precision.
+          new BukkitRunnable() {
+              @Override
+              public void run() {
+            	  sendActionBar(player, "");
+              }
+          }.runTaskLater(plugin, duration + 1);
+      }
+
+      // Re-sends the messages every 3 seconds so it doesn't go away from the player's screen.
+      while (duration > 40) {
+          duration -= 40;
+          new BukkitRunnable() {
+              @Override
+              public void run() {
+                  sendActionBar(player, message);
+              }
+          }.runTaskLater(plugin, (long) duration);
+      }
+  }
+
+}

src/main/java/pk/ajneb97/libs/titles/TitleAPI.java

@@ -0,0 +1,91 @@
+package pk.ajneb97.libs.titles;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import pk.ajneb97.managers.MessagesManager;
+import pk.ajneb97.utils.OtherUtils;
+
+import java.lang.reflect.Constructor;
+
+
+public class TitleAPI implements Listener {
+
+    public static void sendPacket(Player player, Object packet) {
+        try {
+            Object handle = player.getClass().getMethod("getHandle").invoke(player);
+            Object playerConnection = handle.getClass().getField("playerConnection").get(handle);
+            playerConnection.getClass().getMethod("sendPacket", getNMSClass("Packet")).invoke(playerConnection, packet);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static Class<?> getNMSClass(String name) {
+        String version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+        try {
+            return Class.forName("net.minecraft.server." + version + "." + name);
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static void sendTitle(Player player, Integer fadeIn, Integer stay, Integer fadeOut, String title, String subtitle) {
+    	if(OtherUtils.isNew()) {
+    		if(title.isEmpty()) {
+        		title = " ";
+        	}
+        	if(subtitle.isEmpty()) {
+        		subtitle = " ";
+        	}
+    		player.sendTitle(MessagesManager.getColoredMessage(title), MessagesManager.getColoredMessage(subtitle), fadeIn, stay, fadeOut);
+    		return;
+    	}
+    	try {
+            Object e;
+            Object chatTitle;
+            Object chatSubtitle;
+            Constructor subtitleConstructor;
+            Object titlePacket;
+            Object subtitlePacket;
+
+            if (title != null) {
+                title = ChatColor.translateAlternateColorCodes('&', title);
+                title = title.replaceAll("%player%", player.getDisplayName());
+                // Times packets
+                e = getNMSClass("PacketPlayOutTitle").getDeclaredClasses()[0].getField("TIMES").get((Object) null);
+                chatTitle = getNMSClass("IChatBaseComponent").getDeclaredClasses()[0].getMethod("a", new Class[]{String.class}).invoke((Object) null, new Object[]{"{\"text\":\"" + title + "\"}"});
+                subtitleConstructor = getNMSClass("PacketPlayOutTitle").getConstructor(new Class[]{getNMSClass("PacketPlayOutTitle").getDeclaredClasses()[0], getNMSClass("IChatBaseComponent"), Integer.TYPE, Integer.TYPE, Integer.TYPE});
+                titlePacket = subtitleConstructor.newInstance(new Object[]{e, chatTitle, fadeIn, stay, fadeOut});
+                sendPacket(player, titlePacket);
+
+                e = getNMSClass("PacketPlayOutTitle").getDeclaredClasses()[0].getField("TITLE").get((Object) null);
+                chatTitle = getNMSClass("IChatBaseComponent").getDeclaredClasses()[0].getMethod("a", new Class[]{String.class}).invoke((Object) null, new Object[]{"{\"text\":\"" + title + "\"}"});
+                subtitleConstructor = getNMSClass("PacketPlayOutTitle").getConstructor(new Class[]{getNMSClass("PacketPlayOutTitle").getDeclaredClasses()[0], getNMSClass("IChatBaseComponent")});
+                titlePacket = subtitleConstructor.newInstance(new Object[]{e, chatTitle});
+                sendPacket(player, titlePacket);
+            }
+
+            if (subtitle != null) {
+                subtitle = ChatColor.translateAlternateColorCodes('&', subtitle);
+                subtitle = subtitle.replaceAll("%player%", player.getDisplayName());
+                // Times packets
+                e = getNMSClass("PacketPlayOutTitle").getDeclaredClasses()[0].getField("TIMES").get((Object) null);
+                chatSubtitle = getNMSClass("IChatBaseComponent").getDeclaredClasses()[0].getMethod("a", new Class[]{String.class}).invoke((Object) null, new Object[]{"{\"text\":\"" + title + "\"}"});
+                subtitleConstructor = getNMSClass("PacketPlayOutTitle").getConstructor(new Class[]{getNMSClass("PacketPlayOutTitle").getDeclaredClasses()[0], getNMSClass("IChatBaseComponent"), Integer.TYPE, Integer.TYPE, Integer.TYPE});
+                subtitlePacket = subtitleConstructor.newInstance(new Object[]{e, chatSubtitle, fadeIn, stay, fadeOut});
+                sendPacket(player, subtitlePacket);
+
+                e = getNMSClass("PacketPlayOutTitle").getDeclaredClasses()[0].getField("SUBTITLE").get((Object) null);
+                chatSubtitle = getNMSClass("IChatBaseComponent").getDeclaredClasses()[0].getMethod("a", new Class[]{String.class}).invoke((Object) null, new Object[]{"{\"text\":\"" + subtitle + "\"}"});
+                subtitleConstructor = getNMSClass("PacketPlayOutTitle").getConstructor(new Class[]{getNMSClass("PacketPlayOutTitle").getDeclaredClasses()[0], getNMSClass("IChatBaseComponent"), Integer.TYPE, Integer.TYPE, Integer.TYPE});
+                subtitlePacket = subtitleConstructor.newInstance(new Object[]{e, chatSubtitle, fadeIn, stay, fadeOut});
+                sendPacket(player, subtitlePacket);
+            }
+        } catch (Exception var11) {
+            var11.printStackTrace();
+        }
+    }
+}

src/main/java/pk/ajneb97/listeners/InventoryEditListener.java

@@ -0,0 +1,85 @@
+package pk.ajneb97.listeners;
+
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.event.player.AsyncPlayerChatEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.edit.InventoryEditManager;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+
+public class InventoryEditListener implements Listener {
+
+    private PlayerKits2 plugin;
+    public InventoryEditListener(PlayerKits2 plugin){
+        this.plugin = plugin;
+    }
+    @EventHandler
+    public void closeInventory(InventoryCloseEvent event){
+        Player player = (Player) event.getPlayer();
+        InventoryEditManager invManager = plugin.getInventoryEditManager();
+        InventoryPlayer inventoryPlayer = invManager.getInventoryPlayer(player);
+        if(inventoryPlayer != null) {
+            if(inventoryPlayer.getInventoryName().startsWith("edit_position")){
+                invManager.getInventoryEditPositionManager().closeInventory(inventoryPlayer);
+            }
+        }
+        plugin.getInventoryEditManager().removeInventoryPlayer(player);
+    }
+
+    @EventHandler
+    public void clickInventory(InventoryClickEvent event){
+        Player player = (Player) event.getWhoClicked();
+        InventoryEditManager invManager = plugin.getInventoryEditManager();
+        InventoryPlayer inventoryPlayer = invManager.getInventoryPlayer(player);
+        if(inventoryPlayer != null) {
+            ClickType clickType = event.getClick();
+
+            //Special cases before
+            if(inventoryPlayer.getInventoryName().startsWith("edit_display_")){
+                invManager.getInventoryEditDisplayManager().clickInventory(inventoryPlayer,
+                        event.getCurrentItem(),event.getSlot(),clickType,event);
+                return;
+            }else if(inventoryPlayer.getInventoryName().equals("edit_items")){
+                invManager.getInventoryEditKitItemsManager().clickInventory(inventoryPlayer,
+                        event.getCurrentItem(),event.getSlot(),clickType,event);
+                return;
+            }else if(inventoryPlayer.getInventoryName().startsWith("edit_position")){
+                invManager.getInventoryEditPositionManager().clickInventory(inventoryPlayer,
+                        event.getCurrentItem(),event.getSlot(),clickType,event);
+                return;
+            }
+
+            event.setCancelled(true);
+            if(event.getCurrentItem() == null || event.getSlotType() == null){
+                return;
+            }
+
+            if(event.getClickedInventory().equals(player.getOpenInventory().getTopInventory())) {
+                invManager.clickInventory(inventoryPlayer,event.getCurrentItem(),event.getSlot(),clickType);
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onChat(AsyncPlayerChatEvent event){
+        Player player = event.getPlayer();
+        InventoryEditManager invManager = plugin.getInventoryEditManager();
+        InventoryPlayer inventoryPlayer = invManager.getInventoryPlayer(player);
+        if(inventoryPlayer != null) {
+            event.setCancelled(true);
+            new BukkitRunnable(){
+                @Override
+                public void run() {
+                    invManager.writeChat(inventoryPlayer, ChatColor.stripColor(event.getMessage()));
+                }
+            }.runTaskLater(plugin,1L);
+        }
+    }
+}

src/main/java/pk/ajneb97/listeners/PlayerListener.java

@@ -0,0 +1,51 @@
+package pk.ajneb97.listeners;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.InventoryManager;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+
+public class PlayerListener implements Listener {
+
+    private PlayerKits2 plugin;
+    public PlayerListener(PlayerKits2 plugin){
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event){
+        Player player = event.getPlayer();
+        plugin.getPlayerDataManager().manageJoin(player);
+
+    }
+
+    @EventHandler
+    public void closeInventory(InventoryCloseEvent event){
+        Player player = (Player) event.getPlayer();
+        plugin.getInventoryManager().removeInventoryPlayer(player);
+    }
+
+    @EventHandler
+    public void clickInventory(InventoryClickEvent event){
+        Player player = (Player) event.getWhoClicked();
+        InventoryManager invManager = plugin.getInventoryManager();
+        InventoryPlayer inventoryPlayer = invManager.getInventoryPlayer(player);
+        if(inventoryPlayer != null) {
+            event.setCancelled(true);
+            if(event.getCurrentItem() == null || event.getSlotType() == null){
+                return;
+            }
+
+            if(event.getClickedInventory().equals(player.getOpenInventory().getTopInventory())) {
+                ClickType clickType = event.getClick();
+                invManager.clickInventory(inventoryPlayer,event.getCurrentItem(),clickType);
+            }
+        }
+    }
+}

src/main/java/pk/ajneb97/managers/DependencyManager.java

@@ -0,0 +1,36 @@
+package pk.ajneb97.managers;
+
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import pk.ajneb97.PlayerKits2;
+
+public class DependencyManager {
+
+    private PlayerKits2 plugin;
+
+    private boolean isPlaceholderAPI;
+    private Economy vaultEconomy;
+
+    public DependencyManager(PlayerKits2 plugin){
+        this.plugin = plugin;
+
+        if(Bukkit.getServer().getPluginManager().getPlugin("PlaceholderAPI") != null){
+            isPlaceholderAPI = true;
+        }
+        if(Bukkit.getServer().getPluginManager().getPlugin("Vault") != null){
+            RegisteredServiceProvider<Economy> rsp = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
+            if(rsp != null){
+                vaultEconomy = rsp.getProvider();
+            }
+        }
+    }
+
+    public boolean isPlaceholderAPI() {
+        return isPlaceholderAPI;
+    }
+
+    public Economy getVaultEconomy() {
+        return vaultEconomy;
+    }
+}

src/main/java/pk/ajneb97/managers/InventoryManager.java

@@ -0,0 +1,362 @@
+package pk.ajneb97.managers;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.configs.MainConfigManager;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.model.KitAction;
+import pk.ajneb97.model.internal.GiveKitInstructions;
+import pk.ajneb97.model.internal.KitPosition;
+import pk.ajneb97.model.internal.KitVariable;
+import pk.ajneb97.model.internal.PlayerKitsMessageResult;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+import pk.ajneb97.model.inventory.ItemKitInventory;
+import pk.ajneb97.model.inventory.KitInventory;
+import pk.ajneb97.model.item.KitItem;
+import pk.ajneb97.utils.ItemUtils;
+import pk.ajneb97.utils.PlayerUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class InventoryManager {
+
+    private PlayerKits2 plugin;
+    private ArrayList<KitInventory> inventories;
+    private ArrayList<InventoryPlayer> players;
+    private InventoryRequirementsManager inventoryRequirementsManager;
+    public InventoryManager(PlayerKits2 plugin){
+        this.plugin = plugin;
+        this.players = new ArrayList<>();
+        this.inventoryRequirementsManager = new InventoryRequirementsManager(plugin,this);
+    }
+
+    public ArrayList<InventoryPlayer> getPlayers() {
+        return players;
+    }
+
+    public ArrayList<KitInventory> getInventories() {
+        return inventories;
+    }
+
+    public InventoryRequirementsManager getInventoryRequirementsManager() {
+        return inventoryRequirementsManager;
+    }
+
+    public void setInventories(ArrayList<KitInventory> inventories) {
+        this.inventories = inventories;
+    }
+
+    public KitInventory getInventory(String name){
+        for(KitInventory kitInventory : inventories){
+            if(kitInventory.getName().equals(name)){
+                return kitInventory;
+            }
+        }
+        return null;
+    }
+
+    public InventoryPlayer getInventoryPlayer(Player player){
+        for(InventoryPlayer inventoryPlayer : players){
+            if(inventoryPlayer.getPlayer().equals(player)){
+                return inventoryPlayer;
+            }
+        }
+        return null;
+    }
+
+    public void removeInventoryPlayer(Player player){
+        for(int i=0;i<players.size();i++){
+            if(players.get(i).getPlayer().equals(player)){
+                players.remove(i);
+            }
+        }
+    }
+
+    public void openInventory(InventoryPlayer inventoryPlayer){
+        KitInventory kitInventory = getInventory(inventoryPlayer.getInventoryName());
+
+        Inventory inv = Bukkit.createInventory(null,kitInventory.getSlots(),
+                MessagesManager.getColoredMessage(kitInventory.getTitle()));
+
+        List<ItemKitInventory> items = kitInventory.getItems();
+        KitItemManager kitItemManager = plugin.getKitItemManager();
+        KitsManager kitsManager = plugin.getKitsManager();
+        PlayerDataManager playerDataManager = plugin.getPlayerDataManager();
+        MessagesManager msgManager = plugin.getMessagesManager();
+
+        //Add items for all inventories
+        for(ItemKitInventory itemInventory : items){
+            for(int slot : itemInventory.getSlots()){
+                String type = itemInventory.getType();
+                if(type != null){
+                    if(type.startsWith("kit: ")){
+                        setKit(type.replace("kit: ",""),inventoryPlayer.getPlayer(),inv,slot,kitsManager
+                                ,playerDataManager,kitItemManager,msgManager);
+                    }
+                    continue;
+                }
+
+                ItemStack item = kitItemManager.createItemFromKitItem(itemInventory.getItem(),inventoryPlayer.getPlayer());
+
+                if(inventoryPlayer.getInventoryName().equals("buy_requirements_inventory")){
+                    inventoryRequirementsManager.configureRequirementsItem(item,inventoryPlayer.getKitName(),inventoryPlayer.getPlayer());
+                }
+
+                String openInventory = itemInventory.getOpenInventory();
+                if(openInventory != null) {
+                    item = ItemUtils.setTagStringItem(plugin,item, "playerkits_open_inventory", openInventory);
+                }
+                List<String> commands = itemInventory.getCommands();
+                if(commands != null && !commands.isEmpty()) {
+                    String commandList = "";
+                    for(int i=0;i<commands.size();i++) {
+                        if(i==commands.size()-1) {
+                            commandList=commandList+commands.get(i);
+                        }else {
+                            commandList=commandList+commands.get(i)+"|";
+                        }
+                    }
+                    item = ItemUtils.setTagStringItem(plugin,item, "playerkits_item_commands", commandList);
+                }
+
+                inv.setItem(slot,item);
+            }
+        }
+
+        //Special items for some inventories
+        if(inventoryPlayer.getInventoryName().equals("preview_inventory")){
+            setKitPreviewItems(inv,inventoryPlayer,kitInventory);
+        }
+
+
+        inventoryPlayer.getPlayer().openInventory(inv);
+        players.add(inventoryPlayer);
+    }
+
+    public void setKitPreviewItems(Inventory inv,InventoryPlayer inventoryPlayer,KitInventory kitInventory){
+        KitItemManager kitItemManager = plugin.getKitItemManager();
+        KitsManager kitsManager = plugin.getKitsManager();
+
+        Kit kit = kitsManager.getKitByName(inventoryPlayer.getKitName());
+        if(kit == null){
+            return;
+        }
+
+        // Create a list with all items including actions display items
+        ArrayList<KitItem> allItems = new ArrayList<>();
+        allItems.addAll(kit.getItems());
+        for(KitAction kitAction : kit.getClaimActions()){
+            KitItem kitItem = kitAction.getDisplayItem();
+            if(kitItem != null){
+                allItems.add(kitItem);
+            }
+        }
+
+        int slot = 0;
+        for(KitItem kitItem : allItems){
+            ItemStack currentItem = inv.getItem(slot);
+            if(currentItem != null && !currentItem.equals(Material.AIR)){
+                continue;
+            }
+
+            ItemStack item = kitItemManager.createItemFromKitItem(kitItem,inventoryPlayer.getPlayer());
+            if(kitItem.getPreviewSlot() != -1){
+                inv.setItem(kitItem.getPreviewSlot(),item);
+            }else{
+                inv.setItem(slot,item);
+            }
+            slot++;
+
+            if(slot >= kitInventory.getSlots()){
+                break;
+            }
+        }
+    }
+
+    public void clickInventory(InventoryPlayer inventoryPlayer, ItemStack item, ClickType clickType){
+        String kitName = ItemUtils.getTagStringItem(plugin,item,"playerkits_kit");
+        if(kitName != null){
+            clickOnKitItem(inventoryPlayer,kitName,clickType);
+            return;
+        }
+
+        String openInventory = ItemUtils.getTagStringItem(plugin,item,"playerkits_open_inventory");
+        if(openInventory != null){
+            clickOnOpenInventoryItem(inventoryPlayer,openInventory);
+            return;
+        }
+
+        String itemCommands = ItemUtils.getTagStringItem(plugin,item,"playerkits_item_commands");
+        if(itemCommands != null){
+            clickOnCommandItem(inventoryPlayer,itemCommands);
+        }
+
+        //Requirements inventory
+        if(inventoryPlayer.getInventoryName().equals("buy_requirements_inventory")){
+            String buyTag = ItemUtils.getTagStringItem(plugin,item,"playerkits_buy");
+            if(buyTag == null){
+                return;
+            }
+            if(buyTag.equals("yes")){
+                inventoryRequirementsManager.requirementsInventoryBuy(inventoryPlayer);
+            }else{
+                inventoryRequirementsManager.requirementsInventoryCancel(inventoryPlayer);
+            }
+        }
+    }
+
+    public void clickOnKitItem(InventoryPlayer inventoryPlayer,String kitName,ClickType clickType){
+        MainConfigManager mainConfigManager = plugin.getConfigsManager().getMainConfigManager();
+        Player player = inventoryPlayer.getPlayer();
+        FileConfiguration messagesConfig = plugin.getConfigsManager().getMessagesConfigManager().getConfig();
+        MessagesManager msgManager = plugin.getMessagesManager();
+
+        if(clickType.equals(ClickType.RIGHT)){
+            //Preview
+            if(!mainConfigManager.isKitPreview()){
+                return;
+            }
+
+            Kit kit = plugin.getKitsManager().getKitByName(kitName);
+            if(kit.isPermissionRequired()){
+                if(mainConfigManager.isKitPreviewRequiresKitPermission() && !kit.playerHasPermission(player)){
+                    msgManager.sendMessage(player,messagesConfig.getString("cantPreviewError"),true);
+                    return;
+                }
+            }
+            inventoryPlayer.setPreviousInventoryName(inventoryPlayer.getInventoryName());
+            inventoryPlayer.setInventoryName("preview_inventory");
+            inventoryPlayer.setKitName(kitName);
+            openInventory(inventoryPlayer);
+            return;
+        }
+
+
+        PlayerKitsMessageResult result = plugin.getKitsManager().giveKit(player,kitName,
+                new GiveKitInstructions());
+        if(result.isError()){
+            msgManager.sendMessage(player,result.getMessage(),true);
+            return;
+        }else{
+            if(result.isProceedToBuy()){
+                //Open requirements inventory
+                inventoryPlayer.setPreviousInventoryName(inventoryPlayer.getInventoryName());
+                inventoryPlayer.setInventoryName("buy_requirements_inventory");
+                inventoryPlayer.setKitName(kitName);
+                openInventory(inventoryPlayer);
+                return;
+            }
+            msgManager.sendMessage(player,messagesConfig.getString("kitReceived").replace("%kit%",kitName),true);
+        }
+
+        if(mainConfigManager.isCloseInventoryOnClaim()){
+            player.closeInventory();
+            return;
+        }
+
+        openInventory(inventoryPlayer);
+    }
+
+    public void clickOnOpenInventoryItem(InventoryPlayer inventoryPlayer,String openInventory){
+        if(openInventory.equals("previous")){
+            inventoryPlayer.setInventoryName(inventoryPlayer.getPreviousInventoryName());
+        }else{
+            inventoryPlayer.setPreviousInventoryName(inventoryPlayer.getInventoryName());
+            inventoryPlayer.setInventoryName(openInventory);
+        }
+        openInventory(inventoryPlayer);
+    }
+
+    public void clickOnCommandItem(InventoryPlayer inventoryPlayer,String itemCommands){
+        String[] sep = itemCommands.split("\\|");
+        ConsoleCommandSender sender = Bukkit.getConsoleSender();
+        for(String c : sep) {
+            if(c.startsWith("msg %player% ")) {
+                inventoryPlayer.getPlayer().sendMessage(MessagesManager.getColoredMessage(c.replace("msg %player% ", "")));
+            }else{
+                Bukkit.dispatchCommand(sender, c.replace("%player%", inventoryPlayer.getPlayer().getName()));
+            }
+        }
+    }
+
+    public void setKit(String kitName, Player player, Inventory inv, int slot, KitsManager kitsManager, PlayerDataManager playerDataManager
+        ,KitItemManager kitItemManager,MessagesManager msgManager){
+        Kit kit = kitsManager.getKitByName(kitName);
+        if(kit == null){
+            return;
+        }
+
+        ArrayList<KitVariable> variablesToReplace = new ArrayList<>();
+        variablesToReplace.add(new KitVariable("%kit_name%",kit.getName()));
+
+        KitItem kitItem = null;
+        if(!kit.playerHasPermission(player)){
+            kitItem = kit.getDisplayItemNoPermission();
+        }else{
+            //One time
+            if(kit.isOneTime() && !PlayerUtils.isPlayerKitsAdmin(player) && playerDataManager.isKitOneTime(player,kit.getName())){
+                kitItem = kit.getDisplayItemOneTime();
+            }
+
+            //One time requirements
+            if(kit.getRequirements() != null && kit.getRequirements().isOneTimeRequirements()
+                && playerDataManager.isKitBought(player,kit.getName())){
+                kitItem = kit.getDisplayItemOneTimeRequirements();
+            }
+
+            //Cooldown
+            long playerCooldown = playerDataManager.getKitCooldown(player,kit.getName());
+            if(kit.getCooldown() != 0 && !PlayerUtils.isPlayerKitsAdmin(player)){
+                String timeStringMillisDif = playerDataManager.getKitCooldownString(playerCooldown);
+                if(!timeStringMillisDif.isEmpty()) {
+                    kitItem = kit.getDisplayItemCooldown();
+                    variablesToReplace.add(new KitVariable("%time%",timeStringMillisDif));
+                }
+            }
+        }
+        if(kitItem == null){
+            kitItem = kit.getDisplayItemDefault();
+        }
+
+        ItemStack item = kitItemManager.createItemFromKitItem(kitItem,player);
+        kitItemManager.replaceVariables(item,variablesToReplace);
+
+        item = ItemUtils.setTagStringItem(plugin,item, "playerkits_kit", kitName);
+
+        inv.setItem(slot,item);
+    }
+
+
+
+    public KitPosition getKitPositionByKitName(String kitName){
+        for(KitInventory kitInventory : inventories){
+            for(ItemKitInventory itemKitInventory : kitInventory.getItems()){
+                if(itemKitInventory.getType() != null && itemKitInventory.getType().equals("kit: "+kitName)){
+                    return new KitPosition(itemKitInventory.getSlots().get(0), kitInventory.getName());
+                }
+            }
+        }
+        return null;
+    }
+
+    public void removeKitFromInventory(String kitName){
+        for(KitInventory inventory : inventories){
+            List<ItemKitInventory> items = inventory.getItems();
+            for(int i=0;i<items.size();i++){
+                ItemKitInventory item = items.get(i);
+                if(item.getType() != null && item.getType().equals("kit: "+kitName)){
+                    items.remove(i);
+                    i--;
+                }
+            }
+        }
+    }
+}

src/main/java/pk/ajneb97/managers/InventoryRequirementsManager.java

@@ -0,0 +1,127 @@
+package pk.ajneb97.managers;
+
+import me.clip.placeholderapi.PlaceholderAPI;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.model.KitRequirements;
+import pk.ajneb97.model.internal.GiveKitInstructions;
+import pk.ajneb97.model.internal.PlayerKitsMessageResult;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+import pk.ajneb97.utils.PlayerUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class InventoryRequirementsManager {
+
+    private PlayerKits2 plugin;
+    private InventoryManager inventoryManager;
+    public InventoryRequirementsManager(PlayerKits2 plugin, InventoryManager inventoryManager){
+        this.plugin = plugin;
+        this.inventoryManager = inventoryManager;
+    }
+
+    public void configureRequirementsItem(ItemStack item, String kitName, Player player){
+        if(item.hasItemMeta()) {
+            ItemMeta meta = item.getItemMeta();
+            if(!meta.hasLore()){
+                return;
+            }
+            List<String> lore = new ArrayList<>();
+            for(String line : meta.getLore()){
+                if(line.equals("%kit_requirements_message%")){
+                    lore.addAll(replaceRequirementsMessageVariable(kitName,player));
+                }else{
+                    lore.add(line);
+                }
+            }
+            meta.setLore(lore);
+            item.setItemMeta(meta);
+        }
+    }
+
+    public List<String> replaceRequirementsMessageVariable(String kitName, Player player){
+        Kit kit = plugin.getKitsManager().getKitByName(kitName);
+        KitRequirements requirements = kit.getRequirements();
+
+        MessagesManager msgManager = plugin.getMessagesManager();
+        List<String> requirementsMessage = new ArrayList<>(requirements.getMessage());
+        List<String> extraRequirements = requirements.getExtraRequirements();
+        List<Boolean> requirementsBooleans = new ArrayList<>();
+
+        boolean passPrice = plugin.getKitsManager().passPrice(requirements.getPrice(),player);
+        String priceRequirementStatusSymbol =
+                passPrice ? msgManager.getRequirementsMessageStatusSymbolTrue()
+                        : msgManager.getRequirementsMessageStatusSymbolFalse();
+
+        boolean isPlaceholderAPI = plugin.getDependencyManager().isPlaceholderAPI();
+        for(String condition : extraRequirements) {
+            boolean pass = false;
+            if(isPlaceholderAPI) {
+                pass = PlayerUtils.passCondition(player, condition);
+            }
+            requirementsBooleans.add(pass);
+        }
+
+        for(int i=0;i<requirementsMessage.size();i++) {
+            String line = requirementsMessage.get(i);
+            if(line.contains("%status_symbol_requirement_")) {
+                int pos = line.indexOf("%status_symbol_requirement_");
+                int lastPos = line.indexOf("%", pos+1)+1;
+                String variable = line.substring(pos, lastPos);
+                int posNumber = Integer.valueOf(variable.replace("%status_symbol_requirement_","").replace("%", ""));
+                boolean passCondition = requirementsBooleans.get(posNumber-1);
+                if(passCondition) {
+                    line = line.replace(variable, msgManager.getRequirementsMessageStatusSymbolTrue());
+                }else {
+                    line = line.replace(variable, msgManager.getRequirementsMessageStatusSymbolFalse());
+                }
+            }
+
+            //Replace price variable
+            line = line.replace("%status_symbol_price%",priceRequirementStatusSymbol);
+
+            if(isPlaceholderAPI) {
+                line = PlaceholderAPI.setPlaceholders(player, line);
+            }
+
+            line = MessagesManager.getColoredMessage(line);
+            requirementsMessage.set(i, line);
+        }
+
+        return requirementsMessage;
+    }
+
+    public void requirementsInventoryBuy(InventoryPlayer inventoryPlayer){
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        KitRequirements requirements = kit.getRequirements();
+        DependencyManager dependencyManager = plugin.getDependencyManager();
+        boolean isPlaceholderAPI = dependencyManager.isPlaceholderAPI();
+        Player player = inventoryPlayer.getPlayer();
+        FileConfiguration messages = plugin.getConfigsManager().getMessagesConfigManager().getConfig();
+        MessagesManager msgManager = plugin.getMessagesManager();
+
+        //Buy - Unlock
+        KitsManager kitsManager = plugin.getKitsManager();
+        PlayerKitsMessageResult result = kitsManager.giveKit(player,inventoryPlayer.getKitName(),
+                new GiveKitInstructions(false,true,false,false));
+        if(!result.isError()){
+            //Everything is good, open previous inventory.
+            requirementsInventoryCancel(inventoryPlayer);
+        }else{
+            msgManager.sendMessage(player, result.getMessage(), true);
+        }
+    }
+
+    public void requirementsInventoryCancel(InventoryPlayer inventoryPlayer){
+        inventoryPlayer.setInventoryName(inventoryPlayer.getPreviousInventoryName());
+        inventoryPlayer.setKitName(null);
+        inventoryManager.openInventory(inventoryPlayer);
+    }
+
+
+}

src/main/java/pk/ajneb97/managers/KitItemManager.java

@@ -0,0 +1,461 @@
+package pk.ajneb97.managers;
+
+import org.bukkit.Color;
+import org.bukkit.configuration.file.FileConfiguration;
+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.EnchantmentStorageMeta;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.LeatherArmorMeta;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.model.internal.KitVariable;
+import pk.ajneb97.model.item.*;
+import pk.ajneb97.utils.ItemUtils;
+import pk.ajneb97.utils.OtherUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class KitItemManager {
+
+    private PlayerKits2 plugin;
+    public KitItemManager(PlayerKits2 plugin){
+        this.plugin = plugin;
+    }
+
+    public KitItem createKitItemFromItemStack(ItemStack item){
+        KitItem kitItem = new KitItem(item.getType().name());
+        kitItem.setAmount(item.getAmount());
+
+        if(item.getDurability() != 0) {
+            kitItem.setDurability(item.getDurability());
+        }
+
+        if(item.hasItemMeta()) {
+            ItemMeta meta = item.getItemMeta();
+            if(meta.hasDisplayName()) {
+                kitItem.setName(meta.getDisplayName().replace("§", "&"));
+            }
+            if(meta.hasLore()) {
+                List<String> lore = new ArrayList<String>();
+                for(String l : meta.getLore()) {
+                    lore.add(l.replace("§", "&"));
+                }
+                kitItem.setLore(lore);
+            }
+            if(meta.hasEnchants()) {
+                List<String> enchants = new ArrayList<String>();
+                for(Map.Entry<Enchantment,Integer> entry : meta.getEnchants().entrySet()){
+                    String enchant = entry.getKey().getName();
+                    int level = entry.getValue();
+                    enchants.add(enchant+";"+level);
+                }
+                kitItem.setEnchants(enchants);
+            }
+            Set<ItemFlag> flags = meta.getItemFlags();
+            if(flags != null && !flags.isEmpty()) {
+                List<String> flagsList = new ArrayList<String>();
+                for(ItemFlag flag : flags) {
+                    flagsList.add(flag.name());
+                }
+                kitItem.setFlags(flagsList);
+            }
+
+            if(OtherUtils.isNew() && meta.hasCustomModelData()) {
+                kitItem.setCustomModelData(meta.getCustomModelData());
+            }
+
+            if(meta instanceof LeatherArmorMeta) {
+                LeatherArmorMeta meta2 = (LeatherArmorMeta) meta;
+                kitItem.setColor(meta2.getColor().asRGB());
+            }
+
+            if(meta instanceof EnchantmentStorageMeta) {
+                EnchantmentStorageMeta meta2 = (EnchantmentStorageMeta) meta;
+                Map<Enchantment, Integer> enchants = meta2.getStoredEnchants();
+                List<String> enchantsList = new ArrayList<String>();
+                for (Map.Entry<Enchantment, Integer> entry : enchants.entrySet()) {
+                    enchantsList.add(entry.getKey().getName()+";"+entry.getValue().intValue());
+                }
+                if(!enchantsList.isEmpty()) {
+                    kitItem.setBookEnchants(enchantsList);
+                }
+            }
+        }
+
+        List<String> nbtList = ItemUtils.getNBT(plugin,item);
+        if(!nbtList.isEmpty()) {
+            kitItem.setNbt(nbtList);
+        }
+
+        kitItem.setAttributes(ItemUtils.getAttributes(plugin,item));
+        kitItem.setSkullData(ItemUtils.getSkullData(item));
+        kitItem.setPotionData(ItemUtils.getPotionData(item));
+        kitItem.setFireworkData(ItemUtils.getFireworkData(item));
+        kitItem.setBannerData(ItemUtils.getBannerData(item));
+        kitItem.setBookData(ItemUtils.getBookData(item));
+        kitItem.setTrimData(ItemUtils.getArmorTrimData(item));
+
+        return kitItem;
+    }
+    public ItemStack createItemFromKitItem(KitItem kitItem,Player player){
+        ItemStack item = ItemUtils.createItemFromID(kitItem.getId());
+        item.setAmount(kitItem.getAmount());
+
+        short durability = kitItem.getDurability();
+        if(durability != 0) {
+            item.setDurability(durability);
+        }
+
+        //MAIN META
+        ItemMeta meta = item.getItemMeta();
+        String name = kitItem.getName();
+        if(name != null){
+            name = OtherUtils.replaceGlobalVariables(name,player,plugin);
+            meta.setDisplayName(MessagesManager.getColoredMessage(name));
+        }
+
+        List<String> lore = kitItem.getLore();
+        if(lore != null) {
+            List<String> loreCopy = new ArrayList<String>(lore);
+            for(int i=0;i<loreCopy.size();i++) {
+                String line = OtherUtils.replaceGlobalVariables(loreCopy.get(i),player,plugin);
+                loreCopy.set(i, MessagesManager.getColoredMessage(line));
+            }
+            meta.setLore(loreCopy);
+        }
+
+        int customModelData = kitItem.getCustomModelData();
+        if(customModelData != 0) {
+            meta.setCustomModelData(customModelData);
+        }
+
+        List<String> enchants = kitItem.getEnchants();
+        if(enchants != null) {
+            for(int i=0;i<enchants.size();i++) {
+                String[] sep = enchants.get(i).split(";");
+                String enchantName = sep[0];
+                int enchantLevel = Integer.valueOf(sep[1]);
+                meta.addEnchant(Enchantment.getByName(enchantName), enchantLevel, true);
+            }
+        }
+
+        List<String> flags = kitItem.getFlags();
+        if(flags != null) {
+            for(int i=0;i<flags.size();i++) {
+                meta.addItemFlags(ItemFlag.valueOf(flags.get(i)));
+            }
+        }
+        item.setItemMeta(meta);
+
+        //OTHER META
+        int color = kitItem.getColor();
+        if(color != 0) {
+            LeatherArmorMeta meta2 = (LeatherArmorMeta) item.getItemMeta();
+            meta2.setColor(Color.fromRGB(color));
+            item.setItemMeta(meta2);
+        }
+
+        List<String> bookEnchants = kitItem.getBookEnchants();
+        if(bookEnchants != null && !bookEnchants.isEmpty()) {
+            EnchantmentStorageMeta meta2 = (EnchantmentStorageMeta) item.getItemMeta();
+            for(int i=0;i<bookEnchants.size();i++) {
+                String[] sep = bookEnchants.get(i).split(";");
+                String enchantName = sep[0];
+                int level = Integer.valueOf(sep[1]);
+                meta2.addStoredEnchant(Enchantment.getByName(enchantName), level, true);
+            }
+            item.setItemMeta(meta2);
+        }
+
+        //ADVANCED DATA
+        KitItemSkullData skullData = kitItem.getSkullData();
+        ItemUtils.setSkullData(item, skullData, player);
+
+        KitItemPotionData potionData = kitItem.getPotionData();
+        ItemUtils.setPotionData(item, potionData);
+
+        KitItemFireworkData fireworkData = kitItem.getFireworkData();
+        ItemUtils.setFireworkData(item, fireworkData);
+
+        KitItemBannerData bannerData = kitItem.getBannerData();
+        ItemUtils.setBannerData(item, bannerData);
+
+        KitItemBookData bookData = kitItem.getBookData();
+        ItemUtils.setBookData(item, bookData);
+
+        KitItemTrimData trimData = kitItem.getTrimData();
+        ItemUtils.setArmorTrimData(item, trimData);
+
+        List<String> attributes = kitItem.getAttributes();
+        item = ItemUtils.setAttributes(plugin,item, attributes);
+
+        List<String> nbtList = kitItem.getNbt();
+        item = ItemUtils.setNBT(plugin,item, nbtList);
+
+        return item;
+    }
+
+    public void saveKitItemOnConfig(KitItem item,FileConfiguration config,String path){
+        config.set(path+".id", item.getId());
+        config.set(path+".name", item.getName());
+        config.set(path+".amount", item.getAmount());
+        if(item.getDurability() != 0) {
+            config.set(path+".durability", item.getDurability());
+        }
+        if(item.getLore() != null && !item.getLore().isEmpty()) {
+            config.set(path+".lore", item.getLore());
+        }
+        if(item.getEnchants() != null && !item.getEnchants().isEmpty()) {
+            config.set(path+".enchants", item.getEnchants());
+        }
+        if(item.getFlags() != null && !item.getFlags().isEmpty()) {
+            config.set(path+".item_flags", item.getFlags());
+        }
+
+        if(item.getCustomModelData() != 0) {
+            config.set(path+".custom_model_data", item.getCustomModelData());
+        }
+        if(item.getColor() != 0) {
+            config.set(path+".color", item.getColor());
+        }
+        if(item.getNbt() != null && !item.getNbt().isEmpty()) {
+            config.set(path+".nbt", item.getNbt());
+        }
+        if(item.getAttributes() != null && !item.getAttributes().isEmpty()) {
+            config.set(path+".attributes", item.getAttributes());
+        }
+        if(item.getBookEnchants() != null && !item.getBookEnchants().isEmpty()) {
+            config.set(path+".book_enchants", item.getBookEnchants());
+        }
+
+        KitItemSkullData skullData = item.getSkullData();
+        if(skullData != null) {
+            config.set(path+".skull_data.texture", skullData.getTexture());
+            config.set(path+".skull_data.id", skullData.getId());
+            config.set(path+".skull_data.owner", skullData.getOwner());
+        }
+
+        KitItemPotionData potionData = item.getPotionData();
+        if(potionData != null) {
+            if(potionData.getPotionEffects() != null && !potionData.getPotionEffects().isEmpty()) {
+                config.set(path+".potion_data.effects", potionData.getPotionEffects());
+            }
+            config.set(path+".potion_data.extended", potionData.isExtended());
+            config.set(path+".potion_data.upgraded", potionData.isUpgraded());
+            config.set(path+".potion_data.type", potionData.getPotionType());
+            if(potionData.getPotionColor() != 0) {
+                config.set(path+".potion_data.color", potionData.getPotionColor());
+            }
+        }
+
+        KitItemFireworkData fireworkData = item.getFireworkData();
+        if(fireworkData != null) {
+            if(fireworkData.getFireworkRocketEffects() != null && !fireworkData.getFireworkRocketEffects().isEmpty()) {
+                config.set(path+".firework_data.rocket_effects", fireworkData.getFireworkRocketEffects());
+            }
+            config.set(path+".firework_data.star_effect", fireworkData.getFireworkStarEffect());
+            if(fireworkData.getFireworkPower() != 0) {
+                config.set(path+".firework_data.power", fireworkData.getFireworkPower());
+            }
+        }
+
+        KitItemBannerData bannerData = item.getBannerData();
+        if(bannerData != null) {
+            if(bannerData.getPatterns() != null && !bannerData.getPatterns().isEmpty()) {
+                config.set(path+".banner_data.patterns", bannerData.getPatterns());
+            }
+            config.set(path+".banner_data.base_color", bannerData.getBaseColor());
+        }
+
+        KitItemBookData bookData = item.getBookData();
+        if(bookData != null) {
+            config.set(path+".book_data.author", bookData.getAuthor());
+            config.set(path+".book_data.title", bookData.getTitle());
+            config.set(path+".book_data.pages", bookData.getPages());
+            config.set(path+".book_data.generation", bookData.getGeneration());
+        }
+
+        KitItemTrimData trimData = item.getTrimData();
+        if(trimData != null){
+            config.set(path+".trim_data.pattern", trimData.getPattern());
+            config.set(path+".trim_data.material", trimData.getMaterial());
+        }
+
+        if(item.isOffhand()){
+            config.set(path+".offhand", item.isOffhand());
+        }
+        if(item.getPreviewSlot() != -1){
+            config.set(path+".preview_slot", item.getPreviewSlot());
+        }
+    }
+
+    public KitItem getKitItemFromConfig(FileConfiguration config, String path){
+        String id = config.getString(path+".id");
+        String name = config.contains(path+".name") ? config.getString(path+".name") : null;
+        List<String> lore = config.contains(path+".lore") ? config.getStringList(path+".lore") : null;
+        int amount = config.contains(path+".amount") ? config.getInt(path+".amount") : 1;
+        short durability = config.contains(path+".durability") ? (short) config.getInt(path+".durability") : 0;
+        int customModelData = config.contains(path+".custom_model_data") ? config.getInt(path+".custom_model_data") : 0;
+        int color = config.contains(path+".color") ? config.getInt(path+".color") : 0;
+        List<String> enchants = config.contains(path+".enchants") ? config.getStringList(path+".enchants") : null;
+        List<String> flags = config.contains(path+".item_flags") ? config.getStringList(path+".item_flags") : null;
+        List<String> bookEnchants = config.contains(path+".book_enchants") ? config.getStringList(path+".book_enchants") : null;
+        List<String> nbtList = config.contains(path+".nbt") ? config.getStringList(path+".nbt") : null;
+        List<String> attributes = config.contains(path+".attributes") ? config.getStringList(path+".attributes") : null;
+
+        boolean offhand = config.contains(path+".offhand") ? config.getBoolean(path+".offhand") : false;
+        int previewSlot = config.contains(path+".preview_slot") ? config.getInt(path+".preview_slot") : -1;
+
+        KitItemSkullData skullData = null;
+        if(config.contains(path+".skull_data")) {
+            String skullTexture = null;
+            String skullId = null;
+            String skullOwner = null;
+            if(config.contains(path+".skull_data.texture")) {
+                skullTexture = config.getString(path+".skull_data.texture");
+            }
+            if(config.contains(path+".skull_data.id")) {
+                skullId = config.getString(path+".skull_data.id");
+            }
+            if(config.contains(path+".skull_data.owner")) {
+                skullOwner = config.getString(path+".skull_data.owner");
+            }
+            skullData = new KitItemSkullData(skullOwner,skullTexture,skullId);
+        }
+        KitItemPotionData potionData = null;
+        if(config.contains(path+".potion_data")) {
+            List<String> potionEffects = null;
+            boolean extended = false;
+            boolean upgraded = false;
+            String potionType = null;
+            int potionColor = 0;
+            if(config.contains(path+".potion_data.effects")) {
+                potionEffects = config.getStringList(path+".potion_data.effects");
+            }
+            if(config.contains(path+".potion_data.extended")) {
+                extended = config.getBoolean(path+".potion_data.extended");
+            }
+            if(config.contains(path+".potion_data.upgraded")) {
+                upgraded = config.getBoolean(path+".potion_data.upgraded");
+            }
+            if(config.contains(path+".potion_data.type")) {
+                potionType = config.getString(path+".potion_data.type");
+            }
+            if(config.contains(path+".potion_data.color")) {
+                potionColor = config.getInt(path+".potion_data.color");
+            }
+
+            potionData = new KitItemPotionData(upgraded,extended,potionType,potionColor,potionEffects);
+        }
+        KitItemFireworkData fireworkData = null;
+        if(config.contains(path+".firework_data")) {
+            List<String> rocketEffects = null;
+            String starEffect = null;
+            int power = 0;
+            if(config.contains(path+".firework_data.rocket_effects")) {
+                rocketEffects = config.getStringList(path+".firework_data.rocket_effects");
+            }
+            if(config.contains(path+".firework_data.star_effect")) {
+                starEffect = config.getString(path+".firework_data.star_effect");
+            }
+            if(config.contains(path+".firework_data.power")) {
+                power = config.getInt(path+".firework_data.power");
+            }
+
+            fireworkData = new KitItemFireworkData(rocketEffects,starEffect,power);
+        }
+        KitItemBannerData bannerData = null;
+        if(config.contains(path+".banner_data")) {
+            List<String> patterns = null;
+            String baseColor = null;
+            if(config.contains(path+".banner_data.patterns")) {
+                patterns = config.getStringList(path+".banner_data.patterns");
+            }
+            if(config.contains(path+".banner_data.base_color")) {
+                baseColor = config.getString(path+".banner_data.base_color");
+            }
+
+            bannerData = new KitItemBannerData(patterns,baseColor);
+        }
+        KitItemBookData bookData = null;
+        if(config.contains(path+".book_data")) {
+            List<String> pages = config.getStringList(path+".book_data.pages");
+            String author = null;
+            String generation = null;
+            String title = null;
+            if(config.contains(path+".book_data.author")) {
+                author = config.getString(path+".book_data.author");
+            }
+            if(config.contains(path+".book_data.generation")) {
+                generation = config.getString(path+".book_data.generation");
+            }
+            if(config.contains(path+".book_data.title")) {
+                title = config.getString(path+".book_data.title");
+            }
+
+            bookData = new KitItemBookData(pages,author,generation,title);
+        }
+        KitItemTrimData trimData = null;
+        if(config.contains(path+".trim_data")){
+            String material = config.getString(path+".trim_data.material");
+            String pattern = config.getString(path+".trim_data.pattern");
+            trimData = new KitItemTrimData(pattern,material);
+        }
+
+        KitItem kitItem = new KitItem(id);
+        kitItem.setName(name);
+        kitItem.setLore(lore);
+        kitItem.setAmount(amount);
+        kitItem.setDurability(durability);
+        kitItem.setCustomModelData(customModelData);
+        kitItem.setColor(color);
+        kitItem.setEnchants(enchants);
+        kitItem.setFlags(flags);
+        kitItem.setBookEnchants(bookEnchants);
+        kitItem.setNbt(nbtList);
+        kitItem.setAttributes(attributes);
+        kitItem.setSkullData(skullData);
+        kitItem.setPotionData(potionData);
+        kitItem.setFireworkData(fireworkData);
+        kitItem.setBannerData(bannerData);
+        kitItem.setBookData(bookData);
+        kitItem.setTrimData(trimData);
+
+        kitItem.setOffhand(offhand);
+        kitItem.setPreviewSlot(previewSlot);
+
+        return kitItem;
+    }
+
+
+
+    public void replaceVariables(ItemStack item, ArrayList<KitVariable> variables){
+        if(item.hasItemMeta()){
+            ItemMeta meta = item.getItemMeta();
+            if(meta.hasDisplayName()){
+                String newName = meta.getDisplayName();
+                for(KitVariable variable : variables){
+                    newName = newName.replace(variable.getVariable(),variable.getValue());
+                }
+                meta.setDisplayName(newName);
+            }
+            if(meta.hasLore()){
+                List<String> lore = meta.getLore();
+                for(int i=0;i<lore.size();i++){
+                    for(KitVariable variable : variables){
+                        lore.set(i,lore.get(i).replace(variable.getVariable(),variable.getValue()));
+                    }
+                }
+                meta.setLore(lore);
+            }
+            item.setItemMeta(meta);
+        }
+    }
+
+
+}

src/main/java/pk/ajneb97/managers/KitsManager.java

@@ -0,0 +1,407 @@
+package pk.ajneb97.managers;
+
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.configs.MainConfigManager;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.model.KitAction;
+import pk.ajneb97.model.KitRequirements;
+import pk.ajneb97.model.internal.GiveKitInstructions;
+import pk.ajneb97.model.internal.PlayerKitsMessageResult;
+import pk.ajneb97.model.inventory.KitInventory;
+import pk.ajneb97.model.item.KitItem;
+import pk.ajneb97.utils.ActionUtils;
+import pk.ajneb97.utils.OtherUtils;
+import pk.ajneb97.utils.PlayerUtils;
+import java.util.ArrayList;
+import java.util.List;
+
+public class KitsManager {
+
+    private PlayerKits2 plugin;
+    private ArrayList<Kit> kits;
+    public KitsManager(PlayerKits2 plugin){
+        this.plugin = plugin;
+    }
+
+    public PlayerKits2 getPlugin() {
+        return plugin;
+    }
+
+    public void setPlugin(PlayerKits2 plugin) {
+        this.plugin = plugin;
+    }
+
+    public ArrayList<Kit> getKits() {
+        return kits;
+    }
+
+    public void setKits(ArrayList<Kit> kits) {
+        this.kits = kits;
+    }
+
+    public Kit getKitByName(String name){
+        for(Kit kit : kits){
+            if(kit.getName().equals(name)){
+                return kit;
+            }
+        }
+        return null;
+    }
+
+    public void removeKit(String name){
+        for(int i=0;i<kits.size();i++){
+            if(kits.get(i).getName().equals(name)){
+                kits.remove(i);
+                return;
+            }
+        }
+    }
+
+    public void createKit(String kitName,Player player){
+        Kit kit = getKitByName(kitName);
+        FileConfiguration messagesFile = plugin.getConfigsManager().getMessagesConfigManager().getConfig();
+        MainConfigManager mainConfigManager = plugin.getConfigsManager().getMainConfigManager();
+        MessagesManager msgManager = plugin.getMessagesManager();
+        if(kit != null){
+            msgManager.sendMessage(player,messagesFile.getString("kitAlreadyExists").replace("%kit%",kitName),true);
+            return;
+        }
+
+        ItemStack[] inventoryContents = PlayerUtils.getAllInventoryContents(player);
+
+        KitItemManager kitItemManager = plugin.getKitItemManager();
+        ArrayList<KitItem> items = new ArrayList<>();
+        boolean hasArmor = false;
+        for(int i=0;i<inventoryContents.length;i++){
+            ItemStack item = inventoryContents[i];
+            if(item == null || item.getType().equals(Material.AIR)){
+                continue;
+            }
+
+            KitItem kitItem = kitItemManager.createKitItemFromItemStack(item);
+
+            //Check for armor/offhand
+            if(i >= 36 && i<=39){
+                hasArmor = true;
+            }
+            if(i == 40){
+                kitItem.setOffhand(true);
+            }
+
+            items.add(kitItem);
+        }
+
+        if(items.size() == 0){
+            msgManager.sendMessage(player,messagesFile.getString("inventoryEmpty"),true);
+            return;
+        }
+
+        //Set defaults
+        kit = new Kit(kitName);
+        kit.setItems(items);
+        kit.setDefaults(mainConfigManager.getNewKitDefault());
+        kit.setAutoArmor(hasArmor);
+
+        kits.add(kit);
+        plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+
+        msgManager.sendMessage(player,messagesFile.getString("kitCreated").replace("%kit%",kitName),true);
+
+        //Add on inventory
+        InventoryManager inventoryManager = plugin.getInventoryManager();
+        String newKitDefaultInventory = mainConfigManager.getNewKitDefaultInventory();
+        KitInventory inventory = inventoryManager.getInventory(newKitDefaultInventory);
+        if(inventory != null){
+            int resultSlot = inventory.addKitItemOnFirstEmptySlot(kitName);
+            if(resultSlot == -1){
+                msgManager.sendMessage(player,messagesFile.getString("kitNotAddedToInventory"),true);
+            }else{
+                msgManager.sendMessage(player,messagesFile.getString("kitAddedToInventory")
+                        .replace("%inventory%",newKitDefaultInventory).replace("%slot%",resultSlot+""),true);
+                //Update inventory file
+                plugin.getConfigsManager().getInventoryConfigManager().saveKitItemOnConfig(newKitDefaultInventory,resultSlot,kitName);
+            }
+        }
+    }
+
+    public void deleteKit(String kitName,CommandSender sender){
+        FileConfiguration messagesFile = plugin.getConfigsManager().getMessagesConfigManager().getConfig();
+        MessagesManager msgManager = plugin.getMessagesManager();
+        if(getKitByName(kitName) == null){
+            msgManager.sendMessage(sender,messagesFile.getString("kitDoesNotExists")
+                    .replace("%kit%",kitName),true);
+            return;
+        }
+
+        removeKit(kitName);
+        plugin.getConfigsManager().getKitsConfigManager().removeKitFile(kitName);
+        plugin.getInventoryManager().removeKitFromInventory(kitName);
+        plugin.getConfigsManager().getInventoryConfigManager().save();
+
+        msgManager.sendMessage(sender,messagesFile.getString("kitDeleted").replace("%kit%",kitName),true);
+    }
+
+    public PlayerKitsMessageResult giveKit(Player player, String kitName, GiveKitInstructions giveKitInstructions){
+        Kit kit = getKitByName(kitName);
+        FileConfiguration messagesFile = plugin.getConfigsManager().getMessagesConfigManager().getConfig();
+        FileConfiguration configFile = plugin.getConfigsManager().getMainConfigManager().getConfig();
+        PlayerDataManager playerDataManager = plugin.getPlayerDataManager();
+        MessagesManager msgManager = plugin.getMessagesManager();
+
+        if(kit == null){
+            return PlayerKitsMessageResult.error(messagesFile.getString("kitDoesNotExists").replace("%kit%",kitName));
+        }
+
+        //Check properties
+        if(!giveKitInstructions.isFromCommand()){
+            //Permission
+            if(!giveKitInstructions.isIgnorePermission() && !kit.playerHasPermission(player)){
+                sendKitActions(kit.getErrorActions(),player,false);
+                return PlayerKitsMessageResult.error(messagesFile.getString("kitNoPermissions"));
+            }
+
+            //One time
+            if(kit.isOneTime() && !PlayerUtils.isPlayerKitsAdmin(player) && !PlayerUtils.hasOneTimeBypassPermission(player)
+                    && playerDataManager.isKitOneTime(player,kit.getName())){
+                sendKitActions(kit.getErrorActions(),player,false);
+                return PlayerKitsMessageResult.error(messagesFile.getString("oneTimeError"));
+            }
+
+            //Cooldown
+            long playerCooldown = playerDataManager.getKitCooldown(player,kit.getName());
+            if(kit.getCooldown() != 0 && !PlayerUtils.isPlayerKitsAdmin(player) && !PlayerUtils.hasCooldownBypassPermission(player)){
+                long currentMillis = System.currentTimeMillis();
+                long millisDif = playerCooldown-currentMillis;
+                String timeStringMillisDif = OtherUtils.getTime(millisDif/1000, msgManager);
+                if(!timeStringMillisDif.isEmpty()) {
+                    sendKitActions(kit.getErrorActions(),player,false);
+                    return PlayerKitsMessageResult.error(messagesFile.getString("cooldownError")
+                            .replace("%time%",timeStringMillisDif));
+                }
+            }
+
+            //Requirements - Buy
+            KitRequirements kitRequirements = kit.getRequirements();
+            if(!giveKitInstructions.isIgnoreRequirements() && kitRequirements != null){
+                if(!(kitRequirements.isOneTimeRequirements() && playerDataManager.isKitBought(player,kit.getName()))){
+                    if(!giveKitInstructions.isRequirementsSatisfied()){
+                        //Player must buy it first
+                        PlayerKitsMessageResult result = PlayerKitsMessageResult.success();
+                        result.setProceedToBuy(true);
+                        return result;
+                    }
+
+                    //Check price
+                    if(!passPrice(kitRequirements.getPrice(),player)){
+                        sendKitActions(kit.getErrorActions(),player,false);
+                        return PlayerKitsMessageResult.error(messagesFile.getString("requirementsError"));
+                    }
+                    //Check requirements
+                    List<String> requirementsConditions = kitRequirements.getExtraRequirements();
+                    if(plugin.getDependencyManager().isPlaceholderAPI()) {
+                        for(String condition : requirementsConditions) {
+                            boolean passCondition = PlayerUtils.passCondition(player, condition);
+                            if(!passCondition) {
+                                sendKitActions(kit.getErrorActions(),player,false);
+                                return PlayerKitsMessageResult.error(messagesFile.getString("requirementsError"));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+
+        KitItemManager kitItemManager = plugin.getKitItemManager();
+        ArrayList<KitItem> items = kit.getItems();
+
+        //Check amount of free slots, including auto-armor
+        int usedSlots = PlayerUtils.getUsedSlots(player);
+        int freeSlots = 36-usedSlots;
+        int inventoryKitItems = 0; //Items that will be put in the player inventory (not equipment)
+
+        KitItem itemHelmet = null;
+        KitItem itemChestplate = null;
+        KitItem itemLeggings = null;
+        KitItem itemBoots = null;
+        KitItem itemOffhand = null;
+
+        PlayerInventory playerInventory = player.getInventory();
+        for(KitItem item : items){
+            if(kit.isAutoArmor()){
+                String id = item.getId();
+
+                //Check if the item must be put in the player equipment
+                if((id.contains("_HELMET") || id.contains("PLAYER_HELMET") || id.contains("SKULL_ITEM")) && itemHelmet == null && (playerInventory.getHelmet() == null
+                    || playerInventory.getHelmet().getType().equals(Material.AIR))){
+                    itemHelmet = item;
+                    continue;
+                }else if((id.contains("_CHESTPLATE") || id.contains("ELYTRA")) && itemChestplate == null && (playerInventory.getChestplate() == null
+                        || playerInventory.getChestplate().getType().equals(Material.AIR))){
+                    itemChestplate = item;
+                    continue;
+                }else if(id.contains("_LEGGINGS") && itemLeggings == null && (playerInventory.getLeggings() == null
+                        || playerInventory.getLeggings().getType().equals(Material.AIR))){
+                    itemLeggings = item;
+                    continue;
+                }else if(id.contains("_BOOTS") && itemBoots == null && (playerInventory.getBoots() == null
+                        || playerInventory.getBoots().getType().equals(Material.AIR))){
+                    itemBoots = item;
+                    continue;
+                }
+            }
+
+            if(item.isOffhand() && itemOffhand == null && (playerInventory.getItemInOffHand() == null
+                || playerInventory.getItemInOffHand().getType().equals(Material.AIR))){
+                itemOffhand = item;
+                continue;
+            }
+
+            inventoryKitItems++;
+        }
+
+
+        boolean enoughSpace = freeSlots < inventoryKitItems;
+        boolean dropItemsIfFullInventory = configFile.getBoolean("drop_items_if_full_inventory");
+
+        if(enoughSpace && !dropItemsIfFullInventory){
+            sendKitActions(kit.getErrorActions(),player,false);
+            return PlayerKitsMessageResult.error(messagesFile.getString("noSpaceError"));
+        }
+
+        //Actions before
+        sendKitActions(kit.getClaimActions(),player,true);
+
+        //Give kit items
+        for(KitItem kitItem : items){
+            ItemStack item = kitItemManager.createItemFromKitItem(kitItem,player);
+
+            if(itemHelmet != null && kitItem.equals(itemHelmet)){
+                playerInventory.setHelmet(item);
+            }else if(itemChestplate != null && kitItem.equals(itemChestplate)){
+                playerInventory.setChestplate(item);
+            }else if(itemLeggings != null && kitItem.equals(itemLeggings)){
+                playerInventory.setLeggings(item);
+            }else if(itemBoots != null && kitItem.equals(itemBoots)){
+                playerInventory.setBoots(item);
+            }else if(itemOffhand != null && kitItem.equals(itemOffhand)){
+                playerInventory.setItemInOffHand(item);
+            }else{
+                if(playerInventory.firstEmpty() == -1 && dropItemsIfFullInventory){
+                    player.getWorld().dropItemNaturally(player.getLocation(), item);
+                }else{
+                    playerInventory.addItem(item);
+                }
+            }
+        }
+
+        //Actions after
+        sendKitActions(kit.getClaimActions(),player,false);
+
+        //Update properties
+        if(!giveKitInstructions.isFromCommand()){
+            //One time
+            if(kit.isOneTime() && !PlayerUtils.isPlayerKitsAdmin(player) && !PlayerUtils.hasOneTimeBypassPermission(player)){
+                playerDataManager.setKitOneTime(player,kit.getName());
+            }
+
+            //Cooldown
+            if(kit.getCooldown() != 0 && !PlayerUtils.isPlayerKitsAdmin(player) && !PlayerUtils.hasCooldownBypassPermission(player)){
+                long millisMax = System.currentTimeMillis()+(kit.getCooldown()*1000);
+                playerDataManager.setKitCooldown(player,kit.getName(),millisMax);
+            }
+
+            //Requirements - Buy
+            KitRequirements kitRequirements = kit.getRequirements();
+            if(!giveKitInstructions.isIgnoreRequirements() && kitRequirements != null && giveKitInstructions.isRequirementsSatisfied()){
+                //Check price and update balance
+                double price = kitRequirements.getPrice();
+                Economy economy = plugin.getDependencyManager().getVaultEconomy();
+                if(price > 0 && economy != null){
+                    economy.withdrawPlayer(player,price);
+                }
+
+                //Actions
+                List<String> actions = kitRequirements.getActionsOnBuy();
+                for(String action : actions){
+                    executeAction(player,action);
+                }
+
+                //Data
+                if(kitRequirements.isOneTimeRequirements()){
+                    playerDataManager.setKitBought(player,kitName);
+                }
+            }
+        }
+
+        return PlayerKitsMessageResult.success();
+    }
+
+    public void giveFirstJoinKit(Player player){
+        // Will ignore:
+        // - requirements
+        // - permissions
+        String firstJoinKit = plugin.getConfigsManager().getMainConfigManager().getFirstJoinKit();
+        if(firstJoinKit.equals("none")){
+            return;
+        }
+        giveKit(player,firstJoinKit,new GiveKitInstructions(false,false,true,true));
+    }
+
+    public void executeAction(Player player,String actionText){
+        int indexFirst = actionText.indexOf(" ");
+        String actionType = actionText.substring(0,indexFirst).replace(":","");
+        String actionLine = actionText.substring(indexFirst+1);
+        actionLine = OtherUtils.replaceGlobalVariables(actionLine,player,plugin);
+
+        switch(actionType){
+            case "console_command":
+                ActionUtils.consoleCommand(actionLine);
+                break;
+            case "player_command":
+                ActionUtils.playerCommand(player,actionLine);
+                break;
+            case "playsound":
+                ActionUtils.playSound(player,actionLine);
+                break;
+            case "actionbar":
+                ActionUtils.actionbar(player,actionLine,plugin);
+                break;
+            case "title":
+                ActionUtils.title(player,actionLine);
+                break;
+            case "firework":
+                ActionUtils.firework(player,actionLine);
+                break;
+        }
+    }
+
+    public void sendKitActions(ArrayList<KitAction> actions,Player player,boolean beforeItems){
+        for(KitAction action : actions){
+            if(action.isExecuteBeforeItems() == beforeItems){
+                String actionText = action.getAction();
+                executeAction(player,actionText);
+            }
+        }
+    }
+
+    public boolean passPrice(double price,Player player){
+        if(price != 0){
+            Economy economy = plugin.getDependencyManager().getVaultEconomy();
+            if(economy != null){
+                if(economy.getBalance(player) < price){
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+}

src/main/java/pk/ajneb97/managers/MessagesManager.java

@@ -0,0 +1,112 @@
+package pk.ajneb97.managers;
+
+import net.md_5.bungee.api.ChatColor;
+import org.bukkit.command.CommandSender;
+import pk.ajneb97.utils.OtherUtils;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class MessagesManager {
+
+	private String timeSeconds;
+	private String timeMinutes;
+	private String timeHours;
+	private String timeDays;
+	private String requirementsMessageStatusSymbolTrue;
+	private String requirementsMessageStatusSymbolFalse;
+	private String cooldownPlaceholderReady;
+	private String prefix;
+
+
+	public String getTimeSeconds() {
+		return timeSeconds;
+	}
+
+	public void setTimeSeconds(String timeSeconds) {
+		this.timeSeconds = timeSeconds;
+	}
+
+	public String getTimeMinutes() {
+		return timeMinutes;
+	}
+
+	public void setTimeMinutes(String timeMinutes) {
+		this.timeMinutes = timeMinutes;
+	}
+
+	public String getTimeHours() {
+		return timeHours;
+	}
+
+	public void setTimeHours(String timeHours) {
+		this.timeHours = timeHours;
+	}
+
+	public String getTimeDays() {
+		return timeDays;
+	}
+
+	public void setTimeDays(String timeDays) {
+		this.timeDays = timeDays;
+	}
+
+	public String getPrefix() {
+		return prefix;
+	}
+
+	public void setPrefix(String prefix) {
+		this.prefix = prefix;
+	}
+
+	public String getRequirementsMessageStatusSymbolTrue() {
+		return requirementsMessageStatusSymbolTrue;
+	}
+
+	public void setRequirementsMessageStatusSymbolTrue(String requirementsMessageStatusSymbolTrue) {
+		this.requirementsMessageStatusSymbolTrue = requirementsMessageStatusSymbolTrue;
+	}
+
+	public String getRequirementsMessageStatusSymbolFalse() {
+		return requirementsMessageStatusSymbolFalse;
+	}
+
+	public void setRequirementsMessageStatusSymbolFalse(String requirementsMessageStatusSymbolFalse) {
+		this.requirementsMessageStatusSymbolFalse = requirementsMessageStatusSymbolFalse;
+	}
+
+	public String getCooldownPlaceholderReady() {
+		return cooldownPlaceholderReady;
+	}
+
+	public void setCooldownPlaceholderReady(String cooldownPlaceholderReady) {
+		this.cooldownPlaceholderReady = cooldownPlaceholderReady;
+	}
+
+	public void sendMessage(CommandSender sender, String message, boolean prefix){
+		if(!message.isEmpty()){
+			if(prefix){
+				sender.sendMessage(getColoredMessage(this.prefix+message));
+			}else{
+				sender.sendMessage(getColoredMessage(message));
+			}
+		}
+	}
+
+	public static String getColoredMessage(String message) {
+		if(OtherUtils.isNew()) {
+			Pattern pattern = Pattern.compile("#[a-fA-F0-9]{6}");
+			Matcher match = pattern.matcher(message);
+			
+			while(match.find()) {
+				String color = message.substring(match.start(),match.end());
+				message = message.replace(color, ChatColor.of(color)+"");
+				
+				match = pattern.matcher(message);
+			}
+		}
+
+		message = ChatColor.translateAlternateColorCodes('&', message);
+		return message;
+	}
+}

src/main/java/pk/ajneb97/managers/PlayerDataManager.java

@@ -0,0 +1,186 @@
+package pk.ajneb97.managers;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.database.MySQLConnection;
+import pk.ajneb97.model.PlayerData;
+import pk.ajneb97.model.internal.PlayerKitsMessageResult;
+import pk.ajneb97.utils.OtherUtils;
+
+import java.util.ArrayList;
+
+public class PlayerDataManager {
+
+    private PlayerKits2 plugin;
+    private ArrayList<PlayerData> players;
+
+    public PlayerDataManager(PlayerKits2 plugin){
+        this.plugin = plugin;
+    }
+
+    public ArrayList<PlayerData> getPlayers() {
+        return players;
+    }
+
+    public void setPlayers(ArrayList<PlayerData> players) {
+        this.players = players;
+    }
+
+    private PlayerData getPlayer(Player player,boolean create){
+        for(PlayerData playerData : players){
+            if(playerData.getUuid().equals(player.getUniqueId().toString())){
+                return playerData;
+            }
+        }
+
+        if(create){
+            PlayerData playerData = new PlayerData(player.getName(),player.getUniqueId().toString());
+            players.add(playerData);
+            return playerData;
+        }
+        return null;
+    }
+
+    public PlayerData getPlayerByUUID(String uuid){
+        for(PlayerData player : players){
+            if(player.getUuid().equals(uuid)){
+                return player;
+            }
+        }
+        return null;
+    }
+
+    public void removePlayerByUUID(String uuid){
+        for(int i=0;i<players.size();i++){
+            if(players.get(i).getUuid().equals(uuid)){
+                players.remove(i);
+                return;
+            }
+        }
+    }
+
+    public PlayerData getPlayerByName(String name){
+        for(PlayerData player : players){
+            if(player.getName().equals(name)){
+                return player;
+            }
+        }
+        return null;
+    }
+
+    public void setKitCooldown(Player player,String kitName,long cooldown){
+        PlayerData playerData = getPlayer(player,true);
+        boolean creating = playerData.setKitCooldown(kitName,cooldown);
+        if(plugin.getMySQLConnection() != null){
+            plugin.getMySQLConnection().updateKit(playerData,playerData.getKit(kitName),creating);
+        }
+    }
+
+    public long getKitCooldown(Player player,String kitName){
+        PlayerData playerData = getPlayerByUUID(player.getUniqueId().toString());
+        if(playerData == null){
+            return 0;
+        }else{
+            return playerData.getKitCooldown(kitName);
+        }
+    }
+
+    public String getKitCooldownString(long playerCooldown){
+        long currentMillis = System.currentTimeMillis();
+        long millisDif = playerCooldown-currentMillis;
+        String timeStringMillisDif = OtherUtils.getTime(millisDif/1000, plugin.getMessagesManager());
+        return timeStringMillisDif;
+    }
+
+    public void setKitOneTime(Player player,String kitName){
+        PlayerData playerData = getPlayer(player,true);
+        boolean creating = playerData.setKitOneTime(kitName);
+        if(plugin.getMySQLConnection() != null){
+            plugin.getMySQLConnection().updateKit(playerData,playerData.getKit(kitName),creating);
+        }
+    }
+
+    public boolean isKitOneTime(Player player,String kitName){
+        PlayerData playerData = getPlayerByUUID(player.getUniqueId().toString());
+        if(playerData == null){
+            return false;
+        }else{
+            return playerData.getKitOneTime(kitName);
+        }
+    }
+
+    public void setKitBought(Player player,String kitName){
+        PlayerData playerData = getPlayer(player,true);
+        boolean creating = playerData.setKitBought(kitName);
+        if(plugin.getMySQLConnection() != null){
+            plugin.getMySQLConnection().updateKit(playerData,playerData.getKit(kitName),creating);
+        }
+    }
+
+    public boolean isKitBought(Player player,String kitName){
+        PlayerData playerData = getPlayerByUUID(player.getUniqueId().toString());
+        if(playerData == null){
+            return false;
+        }else{
+            return playerData.getKitHasBought(kitName);
+        }
+    }
+
+    public PlayerKitsMessageResult resetKitForPlayer(String name, String kitName){
+        PlayerData playerData = getPlayerByName(name);
+        FileConfiguration messagesConfig = plugin.getConfigsManager().getMessagesConfigManager().getConfig();
+        if(playerData == null){
+            return PlayerKitsMessageResult.error(messagesConfig.getString("playerDataNotFound")
+                    .replace("%player%",name));
+        }
+
+        playerData.resetKit(kitName);
+        if(plugin.getMySQLConnection() != null){
+            plugin.getMySQLConnection().resetKit(playerData.getUuid(),kitName);
+        }
+
+        return PlayerKitsMessageResult.success();
+    }
+
+    public void manageJoin(Player player){
+        // Create or update data
+        if(plugin.getMySQLConnection() != null){
+            MySQLConnection mySQLConnection = plugin.getMySQLConnection();
+            String uuid = player.getUniqueId().toString();
+            mySQLConnection.getPlayer(uuid, playerData -> {
+                removePlayerByUUID(uuid); //Remove data if already exists
+                boolean firstJoin = false;
+                if(playerData != null) {
+                    players.add(playerData);
+                    //Update name if different
+                    if(!playerData.getName().equals(player.getName())){
+                        playerData.setName(player.getName());
+                        mySQLConnection.updatePlayerName(playerData);
+                    }
+                }else {
+                    firstJoin = true;
+                    playerData = new PlayerData(player.getName(),uuid);
+                    players.add(playerData);
+                    //Create if it doesn't exist
+                    mySQLConnection.createPlayer(playerData);
+                }
+                if(firstJoin){
+                    plugin.getKitsManager().giveFirstJoinKit(player);
+                }
+            });
+        }else{
+            boolean firstJoin = false;
+            PlayerData playerData = getPlayerByUUID(player.getUniqueId().toString());
+            if(playerData == null){
+                firstJoin = true;
+                players.add(new PlayerData(player.getName(),player.getUniqueId().toString()));
+            }else{
+                playerData.setName(player.getName());
+            }
+
+            if(firstJoin){
+                plugin.getKitsManager().giveFirstJoinKit(player);
+            }
+        }
+    }
+}

src/main/java/pk/ajneb97/managers/edit/InventoryEditActionsManager.java

@@ -0,0 +1,193 @@
+package pk.ajneb97.managers.edit;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.MessagesManager;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.model.KitAction;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+import pk.ajneb97.utils.InventoryItem;
+import pk.ajneb97.utils.OtherUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class InventoryEditActionsManager {
+
+    private PlayerKits2 plugin;
+    private InventoryEditManager inventoryEditManager;
+    public InventoryEditActionsManager(PlayerKits2 plugin, InventoryEditManager inventoryEditManager){
+        this.plugin = plugin;
+        this.inventoryEditManager = inventoryEditManager;
+    }
+
+    public void openInventory(InventoryPlayer inventoryPlayer,String type) {
+        inventoryPlayer.setInventoryName("edit_actions_"+type);
+        Inventory inv = Bukkit.createInventory(null, 54, MessagesManager.getColoredMessage("&9Editing Kit"));
+
+        //Decoration
+        for(int i=45;i<=52;i++){
+            if(OtherUtils.isLegacy()){
+                new InventoryItem(inv, i, Material.valueOf("STAINED_GLASS_PANE")).dataValue((short) 15).name("").ready();
+            }else{
+                new InventoryItem(inv, i, Material.BLACK_STAINED_GLASS_PANE).name("").ready();
+            }
+        }
+
+        //Set Go Back
+        new InventoryItem(inv, 45, Material.ARROW).name("&eGo Back").ready();
+
+        //Set Add Action
+        new InventoryItem(inv, 53, Material.EMERALD_BLOCK).name("&6&lAdd Action").ready();
+
+        //Set Info Item
+        List<String> lore = new ArrayList<String>();
+        lore.add("&7You are currently editing the actions");
+        if(type.equals("claim")){
+            lore.add("&7when the player claims the kit.");
+        }else{
+            lore.add("&7when there is an error when claiming");
+            lore.add("&7the kit.");
+        }
+        new InventoryItem(inv, 49, Material.COMPASS).name("&6&lInfo").lore(lore).ready();
+
+        //Set Actions
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        ArrayList<KitAction> actions = getKitActionsFromType(kit,type);
+        int slot = 0;
+        for(KitAction kitAction : actions){
+            String executeBeforeItems = "&cNO";
+            if (kitAction.isExecuteBeforeItems()) {
+                executeBeforeItems = "&aYES";
+            }
+
+            lore = new ArrayList<>();
+            lore.add(MessagesManager.getColoredMessage("&f")+kitAction.getAction());
+            lore.add("");
+            lore.add(MessagesManager.getColoredMessage("&7Execute before giving kit items? "+executeBeforeItems));
+            lore.add("");
+            lore.add(MessagesManager.getColoredMessage("&a&lLEFT CLICK &ato edit"));
+            lore.add(MessagesManager.getColoredMessage("&e&lSHIFT+LEFT CLICK &eto alternate execution"));
+            lore.add(MessagesManager.getColoredMessage(" &ebefore giving kit items"));
+            lore.add(MessagesManager.getColoredMessage("&c&lRIGHT CLICK &cto remove"));
+
+            ItemStack item = new ItemStack(Material.PAPER);
+            ItemMeta meta = item.getItemMeta();
+            meta.setDisplayName(MessagesManager.getColoredMessage("&7Command &e#"+(slot+1)));
+            meta.setLore(lore);
+            item.setItemMeta(meta);
+            inv.setItem(slot,item);
+
+            slot++;
+            if(slot >= 44){
+                break;
+            }
+        }
+
+        inventoryPlayer.getPlayer().openInventory(inv);
+        inventoryEditManager.getPlayers().add(inventoryPlayer);
+    }
+
+    public void removeAction(InventoryPlayer inventoryPlayer,int slot){
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        String type = inventoryPlayer.getInventoryName().replace("edit_actions_","");
+        ArrayList<KitAction> actions = getKitActionsFromType(kit,type);
+        actions.remove(slot);
+
+        openInventory(inventoryPlayer,type);
+
+        plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+    }
+
+    public void alternateExecutionBeforeItems(InventoryPlayer inventoryPlayer,int slot){
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        String type = inventoryPlayer.getInventoryName().replace("edit_actions_","");
+        ArrayList<KitAction> actions = getKitActionsFromType(kit,type);
+        KitAction kitAction = actions.get(slot);
+        kitAction.setExecuteBeforeItems(!kitAction.isExecuteBeforeItems());
+
+        openInventory(inventoryPlayer,type);
+
+        plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+    }
+
+    public void clickAddAction(InventoryPlayer inventoryPlayer){
+        Player player = inventoryPlayer.getPlayer();
+        player.sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&7Write the new action to add."));
+        player.sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&fCheck all actions on the wiki: &bhttps://ajneb97.gitbook.io/playerkits-2/"));
+
+        player.closeInventory();
+        String type = inventoryPlayer.getInventoryName().replace("edit_actions_","");
+        inventoryPlayer.setInventoryName("edit_chat_add_action_"+type);
+        inventoryEditManager.getPlayers().add(inventoryPlayer);
+    }
+
+    public void addAction(InventoryPlayer inventoryPlayer,String message){
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        String type = inventoryPlayer.getInventoryName().replace("edit_chat_add_action_","");
+        ArrayList<KitAction> actions = getKitActionsFromType(kit,type);
+        actions.add(new KitAction(message,null,false));
+
+        inventoryEditManager.removeInventoryPlayer(inventoryPlayer.getPlayer());
+        openInventory(inventoryPlayer,type);
+        plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+    }
+
+    public void clickEditAction(InventoryPlayer inventoryPlayer,int slot){
+        Player player = inventoryPlayer.getPlayer();
+        player.sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&7Write the new action to add."));
+        player.sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&fCheck all actions on the wiki: &bhttps://ajneb97.gitbook.io/playerkits-2/"));
+
+        player.closeInventory();
+        String type = inventoryPlayer.getInventoryName().replace("edit_actions_","");
+        inventoryPlayer.setInventoryName("edit_chat_edit_action_"+type+":"+slot);
+        inventoryEditManager.getPlayers().add(inventoryPlayer);
+    }
+
+    public void editAction(InventoryPlayer inventoryPlayer,String message){
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        String[] sep = inventoryPlayer.getInventoryName().replace("edit_chat_edit_action_","").split(":");
+        String type = sep[0];
+        int slot = Integer.parseInt(sep[1]);
+        ArrayList<KitAction> actions = getKitActionsFromType(kit,type);
+        actions.get(slot).setAction(message);
+
+        inventoryEditManager.removeInventoryPlayer(inventoryPlayer.getPlayer());
+        openInventory(inventoryPlayer,type);
+        plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+    }
+
+    public void clickInventory(InventoryPlayer inventoryPlayer, ItemStack item, int slot, ClickType clickType){
+        if(slot == 45){
+            inventoryEditManager.openInventory(inventoryPlayer);
+        }else if(slot >= 0 && slot <= 44 && item != null && !item.getType().equals(Material.AIR)){
+            if(clickType.isLeftClick()){
+                if(clickType.isShiftClick()){
+                    alternateExecutionBeforeItems(inventoryPlayer,slot);
+                }else{
+                    clickEditAction(inventoryPlayer,slot);
+                }
+            }else if(clickType.isRightClick()){
+                removeAction(inventoryPlayer,slot);
+            }
+        }else if(slot == 53){
+            clickAddAction(inventoryPlayer);
+        }
+    }
+
+    public ArrayList<KitAction> getKitActionsFromType(Kit kit,String type){
+        ArrayList<KitAction> actions = null;
+        if(type.equals("claim")){
+            actions = kit.getClaimActions();
+        }else{
+            actions = kit.getErrorActions();
+        }
+        return actions;
+    }
+}

src/main/java/pk/ajneb97/managers/edit/InventoryEditDisplayManager.java

@@ -0,0 +1,160 @@
+package pk.ajneb97.managers.edit;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.MessagesManager;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+import pk.ajneb97.model.item.KitItem;
+import pk.ajneb97.utils.InventoryItem;
+import pk.ajneb97.utils.OtherUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class InventoryEditDisplayManager {
+
+    private PlayerKits2 plugin;
+    private InventoryEditManager inventoryEditManager;
+    public InventoryEditDisplayManager(PlayerKits2 plugin, InventoryEditManager inventoryEditManager){
+        this.plugin = plugin;
+        this.inventoryEditManager = inventoryEditManager;
+    }
+
+    public void openInventory(InventoryPlayer inventoryPlayer, String type) {
+        inventoryPlayer.setInventoryName("edit_display_" + type);
+        Inventory inv = Bukkit.createInventory(null, 27, MessagesManager.getColoredMessage("&9Editing Kit"));
+
+        //Decoration
+        ArrayList<Integer> slots = new ArrayList<>();
+        OtherUtils.addRangeToList(0,11,slots);
+        OtherUtils.addRangeToList(15,26,slots);
+        for(int i : slots){
+            if(OtherUtils.isLegacy()){
+                new InventoryItem(inv, i, Material.valueOf("STAINED_GLASS_PANE")).dataValue((short) 15).name("").ready();
+            }else{
+                new InventoryItem(inv, i, Material.BLACK_STAINED_GLASS_PANE).name("").ready();
+            }
+        }
+
+        //Set Go Back
+        new InventoryItem(inv, 18, Material.ARROW).name("&eGo Back").ready();
+
+        //Info Heads
+        Material headMaterial = null;
+        if(OtherUtils.isLegacy()){
+            headMaterial = Material.valueOf("SKULL_ITEM");
+        }else{
+            headMaterial = Material.PLAYER_HEAD;
+        }
+        List<String> lore = new ArrayList<>();
+        lore.add("&7On this empty space you can place an");
+        lore.add("&7already created custom item, or you can");
+        lore.add("&7do so directly from the config of this kit.");
+        new InventoryItem(inv, 12, headMaterial)
+                .setSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTliZjMyOTJlMTI2YTEwNWI1NGViYTcxM2FhMWIxNTJkNTQxYTFkODkzODgyOWM1NjM2NGQxNzhlZDIyYmYifX19")
+                .name("&6Place item here >>").lore(lore).ready();
+        new InventoryItem(inv, 14, headMaterial)
+                .setSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYmQ2OWUwNmU1ZGFkZmQ4NGU1ZjNkMWMyMTA2M2YyNTUzYjJmYTk0NWVlMWQ0ZDcxNTJmZGM1NDI1YmMxMmE5In19fQ==")
+                .name("&6<< Place item here").lore(lore).ready();
+
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        KitItem kitItem = getKitDisplayItemFromType(kit,type);
+
+        //Set Info Item
+        lore = new ArrayList<>();
+        lore.add("&7You are currently editing the");
+        if(type.equals("permission")){
+            lore.add("&6&lNo Permissions Display Item");
+        }else if(type.equals("onetime")){
+            lore.add("&6&lOne Time Display Item");
+        }else if(type.equals("cooldown")){
+            lore.add("&eSet &6&lCooldown Display Item");
+        }else if(type.equals("requirements")){
+            lore.add("&6&lOne Time Requirements Display Item");
+        }else{
+            lore.add("&6&lDefault Display Item");
+        }
+        new InventoryItem(inv, 0, Material.COMPASS).name("&6&lInfo").lore(lore).ready();
+
+        //Save Item
+        lore = new ArrayList<>();
+        lore.add("&7Click here if you made changes");
+        lore.add("&7to the item, before leaving this");
+        lore.add("&7inventory.");
+        new InventoryItem(inv, 26, Material.EMERALD_BLOCK).name("&6&lSave Item").lore(lore).ready();
+
+        if(kitItem != null){
+            inv.setItem(13,plugin.getKitItemManager().createItemFromKitItem(kitItem, inventoryPlayer.getPlayer()));
+        }
+
+        inventoryPlayer.getPlayer().openInventory(inv);
+        inventoryEditManager.getPlayers().add(inventoryPlayer);
+    }
+
+    public void saveKitItem(InventoryPlayer inventoryPlayer){
+        Inventory inv = inventoryPlayer.getPlayer().getOpenInventory().getTopInventory();
+        if(inv != null) {
+            ItemStack item = inv.getItem(13);
+
+            KitItem kitItem = null;
+            if(item != null && !item.getType().equals(Material.AIR)){
+                kitItem = plugin.getKitItemManager().createKitItemFromItemStack(item);
+            }
+
+            Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+            String type = inventoryPlayer.getInventoryName().replace("edit_display_","");
+            if(type.equals("permission")){
+                kit.setDisplayItemNoPermission(kitItem);
+            }else if(type.equals("onetime")){
+                kit.setDisplayItemOneTime(kitItem);
+            }else if(type.equals("cooldown")){
+                kit.setDisplayItemCooldown(kitItem);
+            }else if(type.equals("requirements")){
+                kit.setDisplayItemOneTimeRequirements(kitItem);
+            }else{
+                kit.setDisplayItemDefault(kitItem);
+            }
+            plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+        }
+    }
+
+    public void clickInventory(InventoryPlayer inventoryPlayer, ItemStack item, int slot, ClickType clickType,InventoryClickEvent event){
+        if(event.getSlotType() == null || event.getClickedInventory() == null){
+            return;
+        }
+        if(event.getClickedInventory().equals(inventoryPlayer.getPlayer().getOpenInventory().getTopInventory())){
+            //Top inventory
+            //Cancel unless is slot 13
+            if(slot != 13){
+                event.setCancelled(true);
+                if(slot == 18){
+                    inventoryEditManager.openInventory(inventoryPlayer);
+                }else if(slot == 26){
+                    saveKitItem(inventoryPlayer);
+                    inventoryPlayer.getPlayer().sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&aDisplay item saved."));
+                }
+            }
+        }
+    }
+
+    public KitItem getKitDisplayItemFromType(Kit kit, String type){
+        KitItem kitItem = kit.getDisplayItemDefault();
+        switch(type){
+            case "permission":
+                return kit.getDisplayItemNoPermission();
+            case "onetime":
+                return kit.getDisplayItemOneTime();
+            case "cooldown":
+                return kit.getDisplayItemCooldown();
+            case "requirements":
+                return kit.getDisplayItemOneTimeRequirements();
+        }
+        return kitItem;
+    }
+}

src/main/java/pk/ajneb97/managers/edit/InventoryEditKitItemsManager.java

@@ -0,0 +1,206 @@
+package pk.ajneb97.managers.edit;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.KitItemManager;
+import pk.ajneb97.managers.MessagesManager;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+import pk.ajneb97.model.item.KitItem;
+import pk.ajneb97.utils.InventoryItem;
+import pk.ajneb97.utils.ItemUtils;
+import pk.ajneb97.utils.OtherUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class InventoryEditKitItemsManager {
+
+    private PlayerKits2 plugin;
+    private InventoryEditManager inventoryEditManager;
+    public InventoryEditKitItemsManager(PlayerKits2 plugin, InventoryEditManager inventoryEditManager){
+        this.plugin = plugin;
+        this.inventoryEditManager = inventoryEditManager;
+    }
+
+    public void openInventory(InventoryPlayer inventoryPlayer){
+        inventoryPlayer.setInventoryName("edit_items");
+        Inventory inv = Bukkit.createInventory(null, 54, MessagesManager.getColoredMessage("&9Editing Kit"));
+
+        //Decoration
+        for(int i=46;i<=52;i++){
+            if(OtherUtils.isLegacy()){
+                new InventoryItem(inv, i, Material.valueOf("STAINED_GLASS_PANE")).dataValue((short) 15).name("").ready();
+            }else{
+                new InventoryItem(inv, i, Material.BLACK_STAINED_GLASS_PANE).name("").ready();
+            }
+        }
+
+        //Set Go Back
+        new InventoryItem(inv, 45, Material.ARROW).name("&eGo Back").ready();
+
+        //Save Item
+        List<String> lore = new ArrayList<>();
+        lore.add("&7If you make any changes in this inventory");
+        lore.add("&7it is very important to click this item");
+        lore.add("&7before closing it or going back.");
+        new InventoryItem(inv, 53, Material.EMERALD_BLOCK).name("&6&lSave Kit Items").lore(lore).ready();
+
+        //Info
+        lore = new ArrayList<>();
+        lore.add("&7Here you can edit the items of the kit.");
+        lore.add("");
+        lore.add("&7If you want to set an item on the offhand");
+        lore.add("&7just RIGHT CLICK it.");
+        lore.add("");
+        lore.add("&7You can move the items to define a custom");
+        lore.add("&7position on the PREVIEW inventory.");
+        new InventoryItem(inv, 49, Material.COMPASS).name("&6&lInfo").lore(lore).ready();
+
+        //Kit Items
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        ArrayList<KitItem> items = kit.getItems();
+        KitItemManager kitItemManager = plugin.getKitItemManager();
+        int slot = 0;
+        for(KitItem kitItem : items){
+            ItemStack item = kitItemManager.createItemFromKitItem(kitItem, null); //Player null means variables will be showed
+
+            int finalSlot = kitItem.getPreviewSlot() != -1 ? kitItem.getPreviewSlot() : slot;
+
+            if(kitItem.isOffhand()){
+                setItemOffHand(inv,item,finalSlot);
+            }else{
+                inv.setItem(finalSlot,item);
+            }
+            slot++;
+        }
+
+        inventoryPlayer.getPlayer().openInventory(inv);
+        inventoryEditManager.getPlayers().add(inventoryPlayer);
+    }
+
+    public void clickOffHand(InventoryPlayer inventoryPlayer, Inventory inv, ItemStack clickedItem, int clickedSlot){
+        if(Bukkit.getVersion().contains("1.8")){
+            inventoryPlayer.getPlayer().sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&cOffhand only works on 1.9+."));
+            return;
+        }
+        String offhand = ItemUtils.getTagStringItem(plugin,clickedItem,"playerkits_offhand");
+        if(offhand != null){
+            //On offhand, remove
+            removeItemOffHand(inv,clickedItem,clickedSlot);
+        }else {
+            //Not on offhand, add
+            setItemOffHand(inv,clickedItem,clickedSlot);
+        }
+
+        //Clear offhand for other items
+        ItemStack[] contents = inv.getContents();
+        for(int i=0;i<contents.length;i++){
+            ItemStack item = contents[i];
+            if(item == null || item.getType().equals(Material.AIR)){
+                continue;
+            }
+            if(clickedSlot == i){
+                continue;
+            }
+
+            String offhandCurrentItem = ItemUtils.getTagStringItem(plugin,item,"playerkits_offhand");
+            if(offhandCurrentItem != null){
+                removeItemOffHand(inv,item,i);
+            }
+        }
+    }
+
+    public void setItemOffHand(Inventory inv,ItemStack item,int slot){
+        List<String> offHandLore = new ArrayList<>();
+        offHandLore.add(" ");
+        offHandLore.add(MessagesManager.getColoredMessage("&c&lRIGHT CLICK &cto remove from offhand"));
+        ItemMeta meta = item.getItemMeta();
+        List<String> itemLore = new ArrayList<>();
+        if(meta.hasLore()){
+            itemLore = meta.getLore();
+        }
+        itemLore.addAll(offHandLore);
+        meta.setLore(itemLore);
+        item.setItemMeta(meta);
+        item = ItemUtils.setTagStringItem(plugin,item,"playerkits_offhand","yes");
+        inv.setItem(slot,item);
+    }
+
+    public void removeItemOffHand(Inventory inv,ItemStack item,int slot){
+        ItemMeta meta = item.getItemMeta();
+        if(meta.hasLore()){
+            List<String> itemLore = meta.getLore();
+            itemLore.remove(itemLore.size()-1);
+            itemLore.remove(itemLore.size()-1);
+            meta.setLore(itemLore);
+        }
+        item.setItemMeta(meta);
+        item = ItemUtils.removeTagItem(plugin,item,"playerkits_offhand");
+        inv.setItem(slot,item);
+    }
+
+    public void saveKitItems(InventoryPlayer inventoryPlayer){
+        Inventory inv = inventoryPlayer.getPlayer().getOpenInventory().getTopInventory();
+        if(inv != null) {
+            Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+            KitItemManager kitItemManager = plugin.getKitItemManager();
+            ArrayList<KitItem> kitItems = new ArrayList<>();
+            ItemStack[] contents = inv.getContents();
+            for(int i=0;i<=44;i++){
+                ItemStack item = contents[i];
+                if(item == null || item.getType().equals(Material.AIR)){
+                    continue;
+                }
+
+                KitItem kitItem = kitItemManager.createKitItemFromItemStack(item);
+                //Check offhand
+                String offhand = ItemUtils.getTagStringItem(plugin,item,"playerkits_offhand");
+                if(offhand != null){
+                    kitItem.setOffhand(true);
+                    kitItem.removeOffHandFromEditInventory();
+                }
+
+                //Preview position
+                kitItem.setPreviewSlot(i);
+
+                kitItems.add(kitItem);
+            }
+
+            kit.setItems(kitItems);
+            plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+        }
+    }
+
+    public void clickInventory(InventoryPlayer inventoryPlayer, ItemStack item, int slot, ClickType clickType, InventoryClickEvent event){
+        if(event.getSlotType() == null || event.getClickedInventory() == null){
+            return;
+        }
+        if(event.getClickedInventory().equals(inventoryPlayer.getPlayer().getOpenInventory().getTopInventory())){
+            //Top inventory
+            //Cancel between 45 and 53
+            //Cancel if right click
+            if(slot >= 45 && slot <= 53){
+                event.setCancelled(true);
+                if(slot == 45){
+                    inventoryEditManager.openInventory(inventoryPlayer);
+                }else if(slot == 53){
+                    saveKitItems(inventoryPlayer);
+                    inventoryPlayer.getPlayer().sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&aKit Items saved."));
+                }
+            }else if(clickType.isRightClick()){
+                event.setCancelled(true);
+                if(item != null){
+                    //Is kit item
+                    clickOffHand(inventoryPlayer,event.getClickedInventory(),item,slot);
+                }
+            }
+        }
+    }
+}

src/main/java/pk/ajneb97/managers/edit/InventoryEditManager.java

@@ -0,0 +1,397 @@
+package pk.ajneb97.managers.edit;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.MessagesManager;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.model.KitAction;
+import pk.ajneb97.model.internal.KitPosition;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+import pk.ajneb97.model.item.KitItem;
+import pk.ajneb97.utils.InventoryItem;
+import pk.ajneb97.utils.OtherUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class InventoryEditManager {
+
+    private PlayerKits2 plugin;
+    private ArrayList<InventoryPlayer> players;
+    private InventoryEditActionsManager inventoryEditActionsManager;
+    private InventoryEditDisplayManager inventoryEditDisplayManager;
+    private InventoryEditKitItemsManager inventoryEditKitItemsManager;
+    private InventoryEditPositionManager inventoryEditPositionManager;
+    private InventoryEditRequirementsManager inventoryEditRequirementsManager;
+    public InventoryEditManager(PlayerKits2 plugin){
+        this.plugin = plugin;
+        this.players = new ArrayList<>();
+        this.inventoryEditActionsManager = new InventoryEditActionsManager(plugin,this);
+        this.inventoryEditDisplayManager = new InventoryEditDisplayManager(plugin,this);
+        this.inventoryEditKitItemsManager = new InventoryEditKitItemsManager(plugin,this);
+        this.inventoryEditPositionManager = new InventoryEditPositionManager(plugin,this);
+        this.inventoryEditRequirementsManager = new InventoryEditRequirementsManager(plugin,this);
+    }
+
+    public InventoryPlayer getInventoryPlayer(Player player){
+        for(InventoryPlayer inventoryPlayer : players){
+            if(inventoryPlayer.getPlayer().equals(player)){
+                return inventoryPlayer;
+            }
+        }
+        return null;
+    }
+
+    public InventoryEditActionsManager getInventoryEditActionsManager() {
+        return inventoryEditActionsManager;
+    }
+
+    public InventoryEditDisplayManager getInventoryEditDisplayManager() {
+        return inventoryEditDisplayManager;
+    }
+
+    public InventoryEditKitItemsManager getInventoryEditKitItemsManager() {
+        return inventoryEditKitItemsManager;
+    }
+
+    public InventoryEditPositionManager getInventoryEditPositionManager() {
+        return inventoryEditPositionManager;
+    }
+
+    public ArrayList<InventoryPlayer> getPlayers() {
+        return players;
+    }
+
+    public void removeInventoryPlayer(Player player){
+        for(int i=0;i<players.size();i++){
+            if(players.get(i).getPlayer().equals(player)){
+                players.remove(i);
+            }
+        }
+    }
+
+    public void openInventory(InventoryPlayer inventoryPlayer) {
+        inventoryPlayer.setInventoryName("edit_main_inventory");
+        Inventory inv = Bukkit.createInventory(null, 45, MessagesManager.getColoredMessage("&9Editing Kit"));
+
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+
+        //Set Position
+        List<String> lore = new ArrayList<String>();
+        lore.add("&7Click to define the position of the display");
+        lore.add("&7item of this kit in the Inventory.");
+        lore.add("");
+        String slot = "none";
+        String inventoryName = "none";
+        KitPosition kitPosition = plugin.getInventoryManager().getKitPositionByKitName(kit.getName());
+        if (kitPosition != null) {
+            slot = kitPosition.getSlot() + "";
+            inventoryName = kitPosition.getInventoryName();
+        }
+        lore.add("&7Current Slot: &a" + slot);
+        lore.add("&7Current Inventory: &a" + inventoryName);
+        new InventoryItem(inv, 10, Material.DROPPER).name("&eSet &6&lSlot").lore(lore).ready();
+
+        //Set Cooldown
+        lore = new ArrayList<String>();
+        lore.add("&7Click to define the cooldown of");
+        lore.add("&7the kit.");
+        lore.add("");
+        lore.add("&7Current Cooldown: &a" + kit.getCooldown() + "(s)");
+        if (OtherUtils.isLegacy()) {
+            new InventoryItem(inv, 11, Material.valueOf("WATCH")).name("&eSet &6&lCooldown").lore(lore).ready();
+        } else {
+            new InventoryItem(inv, 11, Material.CLOCK).name("&eSet &6&lCooldown").lore(lore).ready();
+        }
+
+        //Set Permission Required
+        lore = new ArrayList<String>();
+        lore.add("&7Click to enable/disable whether this kit");
+        lore.add("&7needs permissions to be claimed.");
+        lore.add("&7The permission will be:");
+        lore.add("&eplayerkits.kit."+kit.getName());
+        lore.add("");
+        String permission = "&cNO";
+        if (kit.isPermissionRequired()) {
+            permission = "&aYES";
+        }
+        lore.add("&7Current Status: " + permission);
+        new InventoryItem(inv, 12, Material.REDSTONE_BLOCK).name("&eSet &6&lPermission Required").lore(lore).ready();
+
+        //Set One Time
+        lore = new ArrayList<String>();
+        lore.add("&7Click to enable/disable whether this kit");
+        lore.add("&7should be claimed just one time.");
+        lore.add("");
+        String oneTime = "&cNO";
+        if (kit.isOneTime()) {
+            oneTime = "&aYES";
+        }
+        lore.add("&7Current Status: " + oneTime);
+        new InventoryItem(inv, 20, Material.GHAST_TEAR).name("&eSet &6&lOne Time").lore(lore).ready();
+
+        //Set Auto Armor
+        lore = new ArrayList<String>();
+        lore.add("&7Click to enable/disable whether armor");
+        lore.add("&7should be equipped automatically when");
+        lore.add("&7this kit is claimed.");
+        lore.add("");
+        String autoArmor = "&cNO";
+        if (kit.isAutoArmor()) {
+            autoArmor = "&aYES";
+        }
+        lore.add("&7Current Status: " + autoArmor);
+        new InventoryItem(inv, 21, Material.IRON_CHESTPLATE).name("&eSet &6&lAuto Armor").lore(lore).ready();
+
+        //Display Item DEFAULT
+        Material headMaterial = null;
+        if(OtherUtils.isLegacy()){
+            headMaterial = Material.valueOf("SKULL_ITEM");
+        }else{
+            headMaterial = Material.PLAYER_HEAD;
+        }
+        lore = new ArrayList<String>();
+        lore.add("&7Click to edit the default kit display");
+        lore.add("&7item.");
+        new InventoryItem(inv, 38, headMaterial)
+                .setSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMWNkZTUxNGFmYTE5NGQ1Y2JkMDQ3N2MwNWI3Y2IxODVmZjFkZmZkMGMyZmFkZmFlMWE1YmI4MDY0ODU2Yzg5MiJ9fX0=")
+                .name("&eSet &6&lDefault Display Item").lore(lore).ready();
+
+        //Display Item NO PERMISSION
+        lore = new ArrayList<String>();
+        lore.add("&7Click to edit the kit display item when");
+        lore.add("&7player doesn't have the permissions to");
+        lore.add("&7claim it.");
+        new InventoryItem(inv, 39, headMaterial)
+                .setSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzdkNDk5YTlhZjUyOTllZGE0Y2NkYWMyMDE5ZWZlN2YyNDk2MWYzZTFmY2U3Njk0Y2I2ODIwMjlkMjllOWVhMSJ9fX0=")
+                .name("&eSet &6&lNo Permissions Display Item").lore(lore).ready();
+
+        //Display Item ONE TIME
+        lore = new ArrayList<String>();
+        lore.add("&7Click to edit the kit display item when");
+        lore.add("&7one time option is enabled and the player");
+        lore.add("&7has already claimed it.");
+        new InventoryItem(inv, 40, headMaterial)
+                .setSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMzU3NDc2NmUzZGVjNDkwNGZhNWFhMTU5MjA4ZGFlYzExYzYzYzVlMzI2MTU3YzM2NWViMTY5MDFiNjFmNjQ1YiJ9fX0=")
+                .name("&eSet &6&lOne Time Display Item").lore(lore).ready();
+
+        //Display Item COOLDOWN
+        lore = new ArrayList<String>();
+        lore.add("&7Click to edit the kit display item when");
+        lore.add("&7the player is on cooldown.");
+        new InventoryItem(inv, 41, headMaterial)
+                .setSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvODg3YTc1ZjZjYmNjOGUxN2I4ZmJmYWVlMzM3MGZlZjAyMWMyNWY3MDM1YjI1ZDRjNjU3OTZlZjMzODljZWYwMCJ9fX0=")
+                .name("&eSet &6&lCooldown Display Item").lore(lore).ready();
+
+        //Display Item ONE TIME REQUIREMENTS
+        lore = new ArrayList<String>();
+        lore.add("&7Click to edit the kit display item when");
+        lore.add("&7one time requirements option is enabled and");
+        lore.add("&7the player has already accomplished the");
+        lore.add("&7requirements.");
+        new InventoryItem(inv, 42, headMaterial)
+                .setSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNGU4NmJlNTQ5OWViNDI0NWE0NjFiZGNiODZmZjE2M2M4NTVjMTgyODFmOTcxMDU0MmIxN2ZkMjhiYWU0MjQzYiJ9fX0=")
+                .name("&eSet &6&lOne Time Requirements Display Item").lore(lore).ready();
+
+        //Set Kit Items
+        lore = new ArrayList<String>();
+        lore.add("&7Click to edit the kit items.");
+        lore.add("");
+        lore.add("&7Current Items:");
+        int max = 20;
+        for(KitItem kitItem : kit.getItems()){
+            lore.add(MessagesManager.getColoredMessage("&8- &fx"+kitItem.getAmount()+" "+kitItem.getId()));
+            max--;
+            if(max <= 0){
+                break;
+            }
+        }
+        new InventoryItem(inv, 14, Material.DIAMOND).name("&eSet &6&lKit Items").lore(lore).ready();
+
+        //Set Requirements
+        lore = new ArrayList<String>();
+        lore.add("&7Click to edit the kit requirements.");
+        new InventoryItem(inv, 15, Material.REDSTONE).name("&eSet &6&lRequirements").lore(lore).ready();
+
+        //Set Claim Actions
+        lore = new ArrayList<String>();
+        lore.add("&7Click to edit the actions to execute");
+        lore.add("&7when the player claims the kit.");
+        lore.add("");
+        lore.add("&7Current Actions:");
+        lore = setActionItemLore(kit.getClaimActions(),lore);
+        new InventoryItem(inv, 23, Material.IRON_INGOT).name("&eSet &6&lClaim Actions").lore(lore).ready();
+
+        //Set Error Actions
+        lore = new ArrayList<String>();
+        lore.add("&7Click to edit the actions to execute");
+        lore.add("&7when there is an error when claiming");
+        lore.add("&7the kit.");
+        lore.add("");
+        lore.add("&7Current Actions:");
+        lore = setActionItemLore(kit.getErrorActions(),lore);
+        new InventoryItem(inv, 24, Material.NETHER_BRICK).name("&eSet &6&lError Actions").lore(lore).ready();
+
+        inventoryPlayer.getPlayer().openInventory(inv);
+        players.add(inventoryPlayer);
+    }
+
+    public List<String> setActionItemLore(ArrayList<KitAction> actions,List<String> lore){
+        int max = 20;
+        if(actions.isEmpty()){
+            lore.add(MessagesManager.getColoredMessage("&cNONE"));
+        }else{
+            for(KitAction kitAction : actions){
+                String actionLine = kitAction.getAction();
+                List<String> separatedActionLine = new ArrayList<String>();
+                int currentPos = 0;
+                for(int i=0;i<actionLine.length();i++) {
+                    if(currentPos >= 35 && actionLine.charAt(i) == ' ') {
+                        String m = actionLine.substring(i-currentPos, i);
+                        currentPos = 0;
+                        separatedActionLine.add(m);
+                    }else {
+                        currentPos++;
+                    }
+                    if(i==actionLine.length()-1) {
+                        String m = actionLine.substring(i-currentPos+1, actionLine.length());
+                        separatedActionLine.add(m);
+                    }
+                }
+
+                for(int i=0;i<separatedActionLine.size();i++){
+                    if(i == 0){
+                        lore.add(MessagesManager.getColoredMessage("&8- &f")+separatedActionLine.get(i));
+                    }else{
+                        lore.add(MessagesManager.getColoredMessage("&f")+separatedActionLine.get(i));
+                    }
+                }
+
+                max--;
+                if(max <= 0){
+                    break;
+                }
+            }
+        }
+        return lore;
+    }
+
+    public void setPermissionRequired(InventoryPlayer inventoryPlayer){
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        kit.setPermissionRequired(!kit.isPermissionRequired());
+        openInventory(inventoryPlayer);
+        plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+    }
+
+    public void setOneTime(InventoryPlayer inventoryPlayer){
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        kit.setOneTime(!kit.isOneTime());
+        openInventory(inventoryPlayer);
+        plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+    }
+
+    public void setAutoArmor(InventoryPlayer inventoryPlayer){
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        kit.setAutoArmor(!kit.isAutoArmor());
+        openInventory(inventoryPlayer);
+        plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+    }
+
+    public void clickCooldown(InventoryPlayer inventoryPlayer){
+        Player player = inventoryPlayer.getPlayer();
+        player.sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&7Write the new cooldown of the kit (in seconds)."));
+
+        player.closeInventory();
+        inventoryPlayer.setInventoryName("edit_chat_cooldown");
+        players.add(inventoryPlayer);
+    }
+
+    public void setCooldown(InventoryPlayer inventoryPlayer,String message){
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        Player player = inventoryPlayer.getPlayer();
+        try{
+            int cooldown = Integer.parseInt(message);
+            if(cooldown >= 0){
+                kit.setCooldown(cooldown);
+                removeInventoryPlayer(inventoryPlayer.getPlayer());
+                openInventory(inventoryPlayer);
+                plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+                return;
+            }
+        }catch(Exception e){}
+        player.sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&cYou must use a valid number."));
+    }
+
+    public void clickInventory(InventoryPlayer inventoryPlayer, ItemStack item, int slot, ClickType clickType) {
+        String inventory = inventoryPlayer.getInventoryName();
+
+        if(inventory.equals("edit_main_inventory")){
+            switch(slot){
+                case 10:
+                    inventoryEditPositionManager.openInventory(inventoryPlayer,"main_inventory");
+                    break;
+                case 11:
+                    clickCooldown(inventoryPlayer);
+                    break;
+                case 12:
+                    setPermissionRequired(inventoryPlayer);
+                    break;
+                case 14:
+                    inventoryEditKitItemsManager.openInventory(inventoryPlayer);
+                    break;
+                case 15:
+                    inventoryEditRequirementsManager.openInventory(inventoryPlayer);
+                    break;
+                case 20:
+                    setOneTime(inventoryPlayer);
+                    break;
+                case 21:
+                    setAutoArmor(inventoryPlayer);
+                    break;
+                case 23:
+                    inventoryEditActionsManager.openInventory(inventoryPlayer,"claim");
+                    break;
+                case 24:
+                    inventoryEditActionsManager.openInventory(inventoryPlayer,"error");
+                    break;
+                case 38:
+                    inventoryEditDisplayManager.openInventory(inventoryPlayer,"default");
+                    break;
+                case 39:
+                    inventoryEditDisplayManager.openInventory(inventoryPlayer,"permission");
+                    break;
+                case 40:
+                    inventoryEditDisplayManager.openInventory(inventoryPlayer,"onetime");
+                    break;
+                case 41:
+                    inventoryEditDisplayManager.openInventory(inventoryPlayer,"cooldown");
+                    break;
+                case 42:
+                    inventoryEditDisplayManager.openInventory(inventoryPlayer,"requirements");
+                    break;
+            }
+        }else if(inventory.startsWith("edit_actions_")){
+            inventoryEditActionsManager.clickInventory(inventoryPlayer,item,slot,clickType);
+        }else if(inventory.equals("edit_requirements")){
+            inventoryEditRequirementsManager.clickInventory(inventoryPlayer,item,slot,clickType);
+        }
+    }
+
+    public void writeChat(InventoryPlayer inventoryPlayer,String message){
+        String inventory = inventoryPlayer.getInventoryName();
+        if(inventory.equals("edit_chat_cooldown")){
+            setCooldown(inventoryPlayer,message);
+        }else if(inventory.startsWith("edit_chat_add_action_")){
+            inventoryEditActionsManager.addAction(inventoryPlayer,message);
+        }else if(inventory.startsWith("edit_chat_edit_action_")){
+            inventoryEditActionsManager.editAction(inventoryPlayer,message);
+        }else if(inventory.equals("edit_chat_price")){
+            inventoryEditRequirementsManager.setPrice(inventoryPlayer,message);
+        }
+    }
+}

src/main/java/pk/ajneb97/managers/edit/InventoryEditPositionManager.java

@@ -0,0 +1,157 @@
+package pk.ajneb97.managers.edit;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.scheduler.BukkitRunnable;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.*;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.model.internal.KitVariable;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+import pk.ajneb97.model.inventory.ItemKitInventory;
+import pk.ajneb97.model.inventory.KitInventory;
+import pk.ajneb97.utils.InventoryItem;
+import pk.ajneb97.utils.ItemUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class InventoryEditPositionManager {
+
+    private PlayerKits2 plugin;
+    private InventoryEditManager inventoryEditManager;
+    public InventoryEditPositionManager(PlayerKits2 plugin, InventoryEditManager inventoryEditManager){
+        this.plugin = plugin;
+        this.inventoryEditManager = inventoryEditManager;
+    }
+
+    public void openInventory(InventoryPlayer inventoryPlayer,String positionInventory) {
+        KitInventory kitInventory = plugin.getInventoryManager().getInventory(positionInventory);
+
+        Inventory inv = Bukkit.createInventory(null,kitInventory.getSlots(),
+                MessagesManager.getColoredMessage(kitInventory.getTitle()));
+
+        List<ItemKitInventory> items = kitInventory.getItems();
+        KitItemManager kitItemManager = plugin.getKitItemManager();
+        KitsManager kitsManager = plugin.getKitsManager();
+
+        for(ItemKitInventory itemInventory : items){
+            for(int slot : itemInventory.getSlots()){
+                String type = itemInventory.getType();
+                if(type != null){
+                    if(type.startsWith("kit: ")){
+                        String kitName = type.replace("kit: ","");
+                        Kit kit = kitsManager.getKitByName(kitName);
+                        if(kit == null){
+                            continue;
+                        }
+                        ItemStack item = kitItemManager.createItemFromKitItem(kit.getDisplayItemDefault(),null);
+                        //Check if it is the same kit
+                        if(kitName.equals(inventoryPlayer.getKitName())){
+                            ItemMeta meta = item.getItemMeta();
+                            List<String> extraLore = new ArrayList<>();
+                            extraLore.add(" ");
+                            extraLore.add(MessagesManager.getColoredMessage("&a&lTHIS IS THE CURRENT POSITION OF"));
+                            extraLore.add(MessagesManager.getColoredMessage("&a&lTHE KIT."));
+                            List<String> itemLore = new ArrayList<>();
+                            if(meta.hasLore()){
+                                itemLore = new ArrayList<>(meta.getLore());
+                            }
+                            itemLore.addAll(extraLore);
+                            meta.setLore(itemLore);
+                            item.setItemMeta(meta);
+                        }
+
+                        ArrayList<KitVariable> variablesToReplace = new ArrayList<>();
+                        variablesToReplace.add(new KitVariable("%kit_name%",kit.getName()));
+                        kitItemManager.replaceVariables(item,variablesToReplace);
+
+                        inv.setItem(slot,item);
+                    }
+                    continue;
+                }
+
+                ItemStack item = kitItemManager.createItemFromKitItem(itemInventory.getItem(),inventoryPlayer.getPlayer());
+                String openInventory = itemInventory.getOpenInventory();
+                if(openInventory != null) {
+                    item = ItemUtils.setTagStringItem(plugin,item, "playerkits_open_inventory", openInventory);
+                }
+                inv.setItem(slot,item);
+            }
+        }
+
+        inventoryPlayer.setInventoryName("edit_position;"+positionInventory+";false");
+        inventoryPlayer.getPlayer().openInventory(inv);
+        inventoryPlayer.setInventoryName("edit_position;"+positionInventory+";true");
+        inventoryPlayer.saveInventoryContents();
+        inventoryPlayer.getPlayer().getInventory().clear();
+        //Set Info Item
+        List<String> lore = new ArrayList<String>();
+        lore.add("&7Just click on the position of the");
+        lore.add("&7inventory, where you want the new kit");
+        lore.add("&7item to be displayed.");
+        lore.add("");
+        lore.add("&7You can go back by closing this inventory.");
+        new InventoryItem(inventoryPlayer.getPlayer().getInventory(), 22, Material.COMPASS).name("&6&lInfo").lore(lore).ready();
+        inventoryPlayer.getPlayer().updateInventory();
+        inventoryEditManager.getPlayers().add(inventoryPlayer);
+
+
+    }
+
+    public void setPosition(InventoryPlayer inventoryPlayer,int slot){
+        String positionInventory = inventoryPlayer.getInventoryName().split(";")[1];
+        InventoryManager inventoryManager = plugin.getInventoryManager();
+        String kitName = inventoryPlayer.getKitName();
+
+        // Remove kit position if already exists (check on all inventories)
+        inventoryManager.removeKitFromInventory(kitName);
+
+        KitInventory kitInventory = inventoryManager.getInventory(positionInventory);
+        kitInventory.addKitItemOnSlot(kitName,slot);
+        plugin.getConfigsManager().getInventoryConfigManager().save();
+
+        closeInventory(inventoryPlayer);
+    }
+
+    public void clickInventory(InventoryPlayer inventoryPlayer, ItemStack item, int slot, ClickType clickType, InventoryClickEvent event){
+        event.setCancelled(true);
+        if(event.getSlotType() == null || event.getClickedInventory() == null){
+            return;
+        }
+        if(event.getClickedInventory().equals(inventoryPlayer.getPlayer().getOpenInventory().getTopInventory())){
+            //Should not be an item unless has open inventory tag
+            if(item == null || item.getType().equals(Material.AIR)){
+                //Update position
+                setPosition(inventoryPlayer,slot);
+                inventoryPlayer.getPlayer().sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&aKit position updated."));
+                return;
+            }
+
+            String openInventory = ItemUtils.getTagStringItem(plugin,item,"playerkits_open_inventory");
+            if(openInventory != null){
+                openInventory(inventoryPlayer,openInventory);
+                return;
+            }
+            inventoryPlayer.getPlayer().sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&cThis position is occupied."));
+        }
+    }
+
+    public void closeInventory(InventoryPlayer inventoryPlayer){
+        boolean mustReturn = Boolean.parseBoolean(inventoryPlayer.getInventoryName().split(";")[2]);
+        if(mustReturn){
+            new BukkitRunnable(){
+                @Override
+                public void run() {
+                    inventoryPlayer.restoreSavedInventoryContents();
+                    inventoryEditManager.openInventory(inventoryPlayer);
+                }
+            }.runTaskLater(plugin,1L);
+        }
+    }
+}

src/main/java/pk/ajneb97/managers/edit/InventoryEditRequirementsManager.java

@@ -0,0 +1,126 @@
+package pk.ajneb97.managers.edit;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.MessagesManager;
+import pk.ajneb97.model.Kit;
+import pk.ajneb97.model.KitRequirements;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+import pk.ajneb97.utils.InventoryItem;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class InventoryEditRequirementsManager {
+
+    private PlayerKits2 plugin;
+    private InventoryEditManager inventoryEditManager;
+    public InventoryEditRequirementsManager(PlayerKits2 plugin, InventoryEditManager inventoryEditManager){
+        this.plugin = plugin;
+        this.inventoryEditManager = inventoryEditManager;
+    }
+
+    public void openInventory(InventoryPlayer inventoryPlayer) {
+        inventoryPlayer.setInventoryName("edit_requirements");
+        Inventory inv = Bukkit.createInventory(null, 27, MessagesManager.getColoredMessage("&9Editing Kit"));
+
+        //Set Go Back
+        new InventoryItem(inv, 18, Material.ARROW).name("&eGo Back").ready();
+
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        KitRequirements kitRequirements = kit.getRequirements();
+
+        //Set Price
+        List<String> lore = new ArrayList<String>();
+        lore.add("&7Click to define the price of");
+        lore.add("&7the kit. Requires Vault and an");
+        lore.add("&7economy plugin.");
+        lore.add("");
+        double currentPrice = 0;
+        if(kitRequirements != null){
+            currentPrice = kitRequirements.getPrice();
+        }
+        lore.add("&7Current Price: &a$" + currentPrice);
+        new InventoryItem(inv, 11, Material.EMERALD).name("&eSet &6&lPrice").lore(lore).ready();
+
+        //Set Auto Armor
+        lore = new ArrayList<String>();
+        lore.add("&7Click to enable/disable whether players");
+        lore.add("&7must accomplish the requirements of this");
+        lore.add("&7kit only once.");
+        lore.add("");
+        String oneTimeRequirements = "&cNO";
+        if (kitRequirements != null && kitRequirements.isOneTimeRequirements()) {
+            oneTimeRequirements = "&aYES";
+        }
+        lore.add("&7Current Status: " + oneTimeRequirements);
+        new InventoryItem(inv, 13, Material.GHAST_TEAR).name("&eSet &6&lOne Time Requirements").lore(lore).ready();
+
+        //Set Extra Requirements
+        lore = new ArrayList<String>();
+        lore.add("&7Click to add/edit extra requirements.");
+        lore.add("");
+        lore.add("&cThis feature is not available yet on");
+        lore.add("&cthis GUI! You can use the config.");
+        new InventoryItem(inv, 15, Material.REDSTONE).name("&eSet &6&lExtra Requirements").lore(lore).ready();
+
+        inventoryPlayer.getPlayer().openInventory(inv);
+        inventoryEditManager.getPlayers().add(inventoryPlayer);
+    }
+
+    public void setOneTimeRequirements(InventoryPlayer inventoryPlayer){
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        KitRequirements kitRequirements = kit.getRequirements();
+        if(kitRequirements == null){
+            kitRequirements = new KitRequirements();
+            kit.setRequirements(kitRequirements);
+        }
+        kitRequirements.setOneTimeRequirements(!kitRequirements.isOneTimeRequirements());
+        openInventory(inventoryPlayer);
+        plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+    }
+
+    public void clickPrice(InventoryPlayer inventoryPlayer){
+        Player player = inventoryPlayer.getPlayer();
+        player.sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&7Write the new price of the kit."));
+
+        player.closeInventory();
+        inventoryPlayer.setInventoryName("edit_chat_price");
+        inventoryEditManager.getPlayers().add(inventoryPlayer);
+    }
+
+    public void setPrice(InventoryPlayer inventoryPlayer,String message){
+        Kit kit = plugin.getKitsManager().getKitByName(inventoryPlayer.getKitName());
+        Player player = inventoryPlayer.getPlayer();
+        try{
+            double price = Double.parseDouble(message);
+            if(price >= 0){
+                KitRequirements kitRequirements = kit.getRequirements();
+                if(kitRequirements == null){
+                    kitRequirements = new KitRequirements();
+                }
+                kitRequirements.setPrice(price);
+                inventoryEditManager.removeInventoryPlayer(inventoryPlayer.getPlayer());
+                openInventory(inventoryPlayer);
+                plugin.getConfigsManager().getKitsConfigManager().saveConfig(kit);
+                return;
+            }
+        }catch(Exception e){}
+        player.sendMessage(MessagesManager.getColoredMessage(PlayerKits2.prefix+"&cYou must use a valid number."));
+    }
+
+    public void clickInventory(InventoryPlayer inventoryPlayer, ItemStack item, int slot, ClickType clickType) {
+        if (slot == 18) {
+            inventoryEditManager.openInventory(inventoryPlayer);
+        }else if(slot == 11){
+            clickPrice(inventoryPlayer);
+        }else if(slot == 13){
+            setOneTimeRequirements(inventoryPlayer);
+        }
+    }
+}

src/main/java/pk/ajneb97/model/Kit.java

@@ -0,0 +1,168 @@
+package pk.ajneb97.model;
+
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import pk.ajneb97.model.item.KitItem;
+import pk.ajneb97.utils.PlayerUtils;
+
+import java.util.ArrayList;
+
+public class Kit {
+    private String name;
+    private int cooldown;
+    private boolean permissionRequired;
+    private boolean oneTime;
+    private ArrayList<KitItem> items;
+    private ArrayList<KitAction> claimActions;
+    private ArrayList<KitAction> errorActions;
+
+    private KitItem displayItemDefault;
+    private KitItem displayItemNoPermission;
+    private KitItem displayItemCooldown;
+    private KitItem displayItemOneTime;
+    private KitItem displayItemOneTimeRequirements;
+    private KitRequirements requirements;
+
+    private boolean autoArmor;
+
+    public Kit(String name){
+        this.name = name;
+        this.cooldown = 0;
+        this.autoArmor = false;
+        this.oneTime = false;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getCooldown() {
+        return cooldown;
+    }
+
+    public void setCooldown(int cooldown) {
+        this.cooldown = cooldown;
+    }
+
+
+    public boolean isPermissionRequired() {
+        return permissionRequired;
+    }
+
+    public void setPermissionRequired(boolean permissionRequired) {
+        this.permissionRequired = permissionRequired;
+    }
+
+    public ArrayList<KitItem> getItems() {
+        return items;
+    }
+
+    public void setItems(ArrayList<KitItem> items) {
+        this.items = items;
+    }
+
+    public KitItem getDisplayItemDefault() {
+        return displayItemDefault;
+    }
+
+    public void setDisplayItemDefault(KitItem displayItemDefault) {
+        this.displayItemDefault = displayItemDefault;
+    }
+
+    public KitItem getDisplayItemNoPermission() {
+        return displayItemNoPermission;
+    }
+
+    public void setDisplayItemNoPermission(KitItem displayItemNoPermission) {
+        this.displayItemNoPermission = displayItemNoPermission;
+    }
+
+    public KitItem getDisplayItemCooldown() {
+        return displayItemCooldown;
+    }
+
+    public void setDisplayItemCooldown(KitItem displayItemCooldown) {
+        this.displayItemCooldown = displayItemCooldown;
+    }
+
+    public boolean isAutoArmor() {
+        return autoArmor;
+    }
+
+    public void setAutoArmor(boolean autoArmor) {
+        this.autoArmor = autoArmor;
+    }
+
+    public boolean isOneTime() {
+        return oneTime;
+    }
+
+    public void setOneTime(boolean oneTime) {
+        this.oneTime = oneTime;
+    }
+
+    public ArrayList<KitAction> getClaimActions() {
+        return claimActions;
+    }
+
+    public void setClaimActions(ArrayList<KitAction> claimActions) {
+        this.claimActions = claimActions;
+    }
+
+    public ArrayList<KitAction> getErrorActions() {
+        return errorActions;
+    }
+
+    public void setErrorActions(ArrayList<KitAction> errorActions) {
+        this.errorActions = errorActions;
+    }
+
+    public KitItem getDisplayItemOneTime() {
+        return displayItemOneTime;
+    }
+
+    public void setDisplayItemOneTime(KitItem displayItemOneTime) {
+        this.displayItemOneTime = displayItemOneTime;
+    }
+
+    public KitItem getDisplayItemOneTimeRequirements() {
+        return displayItemOneTimeRequirements;
+    }
+
+    public void setDisplayItemOneTimeRequirements(KitItem displayItemOneTimeRequirements) {
+        this.displayItemOneTimeRequirements = displayItemOneTimeRequirements;
+    }
+
+    public KitRequirements getRequirements() {
+        return requirements;
+    }
+
+    public void setRequirements(KitRequirements requirements) {
+        this.requirements = requirements;
+    }
+
+    public boolean playerHasPermission(CommandSender player){
+        if(permissionRequired){
+            return PlayerUtils.isPlayerKitsAdmin(player) || player.hasPermission("playerkits.kit."+name);
+        }
+        return true;
+    }
+
+    public void setDefaults(Kit defaultKit){
+        cooldown = defaultKit.getCooldown();
+        oneTime = defaultKit.isOneTime();
+        permissionRequired = defaultKit.isPermissionRequired();
+        claimActions = defaultKit.getClaimActions();
+        errorActions = defaultKit.getErrorActions();
+        displayItemDefault = defaultKit.getDisplayItemDefault();
+        displayItemNoPermission = defaultKit.getDisplayItemNoPermission();
+        displayItemCooldown = defaultKit.getDisplayItemCooldown();
+        displayItemOneTime = defaultKit.getDisplayItemOneTime();
+        displayItemOneTimeRequirements = defaultKit.getDisplayItemOneTimeRequirements();
+        autoArmor = defaultKit.isAutoArmor();
+    }
+}

src/main/java/pk/ajneb97/model/KitAction.java

@@ -0,0 +1,39 @@
+package pk.ajneb97.model;
+
+import pk.ajneb97.model.item.KitItem;
+
+public class KitAction {
+    private String action;
+    private KitItem displayItem;
+    private boolean executeBeforeItems;
+
+    public KitAction(String action, KitItem displayItem, boolean executeBeforeItems) {
+        this.action = action;
+        this.displayItem = displayItem;
+        this.executeBeforeItems = executeBeforeItems;
+    }
+
+    public String getAction() {
+        return action;
+    }
+
+    public void setAction(String action) {
+        this.action = action;
+    }
+
+    public KitItem getDisplayItem() {
+        return displayItem;
+    }
+
+    public void setDisplayItem(KitItem displayItem) {
+        this.displayItem = displayItem;
+    }
+
+    public boolean isExecuteBeforeItems() {
+        return executeBeforeItems;
+    }
+
+    public void setExecuteBeforeItems(boolean executeBeforeItems) {
+        this.executeBeforeItems = executeBeforeItems;
+    }
+}

src/main/java/pk/ajneb97/model/KitRequirements.java

@@ -0,0 +1,71 @@
+package pk.ajneb97.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class KitRequirements {
+
+    private boolean oneTimeRequirements;
+    private double price;
+    private List<String> extraRequirements;
+    private List<String> message;
+    private List<String> actionsOnBuy;
+
+    public KitRequirements(boolean oneTimeRequirements, List<String> extraRequirements, List<String> message,
+                           List<String> actionsOnBuy,double price) {
+        this.oneTimeRequirements = oneTimeRequirements;
+        this.extraRequirements = extraRequirements;
+        this.message = message;
+        this.actionsOnBuy = actionsOnBuy;
+        this.price = price;
+    }
+
+    public KitRequirements(){
+        extraRequirements = new ArrayList<>();
+        message = new ArrayList<>();
+        message.add("&6You need $5000 to get this kit.");
+        message.add("&8Status: &7$%vault_eco_balance% &8- %status_symbol_price%");
+        actionsOnBuy = new ArrayList<>();
+    }
+
+    public boolean isOneTimeRequirements() {
+        return oneTimeRequirements;
+    }
+
+    public void setOneTimeRequirements(boolean oneTimeRequirements) {
+        this.oneTimeRequirements = oneTimeRequirements;
+    }
+
+
+    public List<String> getMessage() {
+        return message;
+    }
+
+    public void setMessage(List<String> message) {
+        this.message = message;
+    }
+
+    public List<String> getActionsOnBuy() {
+        return actionsOnBuy;
+    }
+
+    public void setActionsOnBuy(List<String> actionsOnBuy) {
+        this.actionsOnBuy = actionsOnBuy;
+    }
+
+    public double getPrice() {
+        return price;
+    }
+
+    public void setPrice(double price) {
+        this.price = price;
+    }
+
+    public List<String> getExtraRequirements() {
+        return extraRequirements;
+    }
+
+    public void setExtraRequirements(List<String> extraRequirements) {
+        this.extraRequirements = extraRequirements;
+    }
+}

src/main/java/pk/ajneb97/model/PlayerData.java

@@ -0,0 +1,128 @@
+package pk.ajneb97.model;
+
+import java.util.ArrayList;
+
+public class PlayerData {
+
+    private String name;
+    private String uuid;
+
+    private ArrayList<PlayerDataKit> kits;
+
+    public PlayerData(String name,String uuid){
+        this.name = name;
+        this.uuid = uuid;
+        this.kits = new ArrayList<PlayerDataKit>();
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getUuid() {
+        return uuid;
+    }
+
+    public void setUuid(String uuid) {
+        this.uuid = uuid;
+    }
+
+    public ArrayList<PlayerDataKit> getKits() {
+        return kits;
+    }
+
+    public void setKits(ArrayList<PlayerDataKit> kits) {
+        this.kits = kits;
+    }
+
+    public void addKit(PlayerDataKit kit){
+        this.kits.add(kit);
+    }
+
+    public PlayerDataKit getKit(String kitName){
+        for(PlayerDataKit kit : kits){
+            if(kit.getName().equals(kitName)){
+                return kit;
+            }
+        }
+        return null;
+    }
+
+    public boolean setKitCooldown(String kitName, long cooldown){
+        PlayerDataKit playerDataKit = getKit(kitName);
+        boolean creating = false;
+        if(playerDataKit == null){
+            playerDataKit = new PlayerDataKit(kitName);
+            kits.add(playerDataKit);
+            creating = true;
+        }
+
+        playerDataKit.setCooldown(cooldown);
+        return creating;
+    }
+
+    public long getKitCooldown(String kitName){
+        PlayerDataKit playerDataKit = getKit(kitName);
+        if(playerDataKit == null){
+            return 0;
+        }else{
+            return playerDataKit.getCooldown();
+        }
+    }
+
+    public boolean setKitOneTime(String kitName){
+        PlayerDataKit playerDataKit = getKit(kitName);
+        boolean creating = false;
+        if(playerDataKit == null){
+            playerDataKit = new PlayerDataKit(kitName);
+            kits.add(playerDataKit);
+            creating = true;
+        }
+
+        playerDataKit.setOneTime(true);
+        return creating;
+    }
+
+    public boolean getKitOneTime(String kitName){
+        PlayerDataKit playerDataKit = getKit(kitName);
+        if(playerDataKit == null){
+            return false;
+        }else{
+            return playerDataKit.isOneTime();
+        }
+    }
+
+    public boolean setKitBought(String kitName){
+        PlayerDataKit playerDataKit = getKit(kitName);
+        boolean creating = false;
+        if(playerDataKit == null){
+            playerDataKit = new PlayerDataKit(kitName);
+            kits.add(playerDataKit);
+            creating = true;
+        }
+
+        playerDataKit.setBought(true);
+        return creating;
+    }
+
+    public boolean getKitHasBought(String kitName){
+        PlayerDataKit playerDataKit = getKit(kitName);
+        if(playerDataKit == null){
+            return false;
+        }else{
+            return playerDataKit.isBought();
+        }
+    }
+
+    public void resetKit(String kitName){
+        for(int i=0;i<kits.size();i++){
+            if(kits.get(i).getName().equals(kitName)){
+                kits.remove(i);
+            }
+        }
+    }
+}

src/main/java/pk/ajneb97/model/PlayerDataKit.java

@@ -0,0 +1,48 @@
+package pk.ajneb97.model;
+
+public class PlayerDataKit {
+
+    private String name;
+    private long cooldown; //Cooldown calculated
+    private boolean oneTime;
+    private boolean bought;
+
+    public PlayerDataKit(String name) {
+        this.name = name;
+        this.cooldown = 0;
+        this.oneTime = false;
+        this.bought = false;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public long getCooldown() {
+        return cooldown;
+    }
+
+    public void setCooldown(long cooldown) {
+        this.cooldown = cooldown;
+    }
+
+    public boolean isOneTime() {
+        return oneTime;
+    }
+
+    public void setOneTime(boolean oneTime) {
+        this.oneTime = oneTime;
+    }
+
+    public boolean isBought() {
+        return bought;
+    }
+
+    public void setBought(boolean bought) {
+        this.bought = bought;
+    }
+}

src/main/java/pk/ajneb97/model/internal/GiveKitInstructions.java

@@ -0,0 +1,55 @@
+package pk.ajneb97.model.internal;
+
+public class GiveKitInstructions {
+
+    private boolean fromCommand; //Allows to ignore some errors, like permissions, cooldown, one time...
+    private boolean requirementsSatisfied; //The player is buying the kit and all requirements are satisfied
+    private boolean ignorePermission;
+    private boolean ignoreRequirements;
+
+    public GiveKitInstructions(){
+        this.fromCommand = false;
+        this.requirementsSatisfied = false;
+        this.ignoreRequirements = false;
+        this.ignorePermission = false;
+    }
+
+    public GiveKitInstructions(boolean fromCommand,boolean requirementsSatisfied,boolean ignorePermission,boolean ignoreRequirements) {
+        this.fromCommand = fromCommand;
+        this.requirementsSatisfied = requirementsSatisfied;
+        this.ignorePermission = ignorePermission;
+        this.ignoreRequirements = ignoreRequirements;
+    }
+
+    public boolean isFromCommand() {
+        return fromCommand;
+    }
+
+    public void setFromCommand(boolean fromCommand) {
+        this.fromCommand = fromCommand;
+    }
+
+    public boolean isRequirementsSatisfied() {
+        return requirementsSatisfied;
+    }
+
+    public void setRequirementsSatisfied(boolean requirementsSatisfied) {
+        this.requirementsSatisfied = requirementsSatisfied;
+    }
+
+    public boolean isIgnorePermission() {
+        return ignorePermission;
+    }
+
+    public void setIgnorePermission(boolean ignorePermission) {
+        this.ignorePermission = ignorePermission;
+    }
+
+    public boolean isIgnoreRequirements() {
+        return ignoreRequirements;
+    }
+
+    public void setIgnoreRequirements(boolean ignoreRequirements) {
+        this.ignoreRequirements = ignoreRequirements;
+    }
+}

src/main/java/pk/ajneb97/model/internal/KitPosition.java

@@ -0,0 +1,28 @@
+package pk.ajneb97.model.internal;
+
+public class KitPosition {
+
+    private int slot;
+    private String inventoryName;
+
+    public KitPosition(int slot, String inventoryName) {
+        this.slot = slot;
+        this.inventoryName = inventoryName;
+    }
+
+    public int getSlot() {
+        return slot;
+    }
+
+    public void setSlot(int slot) {
+        this.slot = slot;
+    }
+
+    public String getInventoryName() {
+        return inventoryName;
+    }
+
+    public void setInventoryName(String inventoryName) {
+        this.inventoryName = inventoryName;
+    }
+}

src/main/java/pk/ajneb97/model/internal/KitVariable.java

@@ -0,0 +1,27 @@
+package pk.ajneb97.model.internal;
+
+public class KitVariable {
+    private String variable;
+    private String value;
+
+    public KitVariable(String variable, String value) {
+        this.variable = variable;
+        this.value = value;
+    }
+
+    public String getVariable() {
+        return variable;
+    }
+
+    public void setVariable(String variable) {
+        this.variable = variable;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+}

src/main/java/pk/ajneb97/model/internal/PlayerKitsMessageResult.java

@@ -0,0 +1,45 @@
+package pk.ajneb97.model.internal;
+
+public class PlayerKitsMessageResult {
+
+    private String message;
+    private boolean error;
+    private boolean proceedToBuy;
+
+    public PlayerKitsMessageResult(String message, boolean error) {
+        this.message = message;
+        this.error = error;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public boolean isError() {
+        return error;
+    }
+
+    public void setError(boolean error) {
+        this.error = error;
+    }
+
+    public static PlayerKitsMessageResult success(){
+        return new PlayerKitsMessageResult(null,false);
+    }
+
+    public static PlayerKitsMessageResult error(String errorMessage){
+        return new PlayerKitsMessageResult(errorMessage,true);
+    }
+
+    public boolean isProceedToBuy() {
+        return proceedToBuy;
+    }
+
+    public void setProceedToBuy(boolean proceedToBuy) {
+        this.proceedToBuy = proceedToBuy;
+    }
+}

src/main/java/pk/ajneb97/model/inventory/InventoryPlayer.java

@@ -0,0 +1,64 @@
+package pk.ajneb97.model.inventory;
+
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class InventoryPlayer {
+    private Player player;
+    private String inventoryName;
+
+    private String previousInventoryName;
+    private String kitName;
+    private ItemStack[] savedInventoryContents;
+
+    public InventoryPlayer(Player player, String inventoryName) {
+        this.player = player;
+        this.inventoryName = inventoryName;
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    public void setPlayer(Player player) {
+        this.player = player;
+    }
+
+    public String getInventoryName() {
+        return inventoryName;
+    }
+
+    public void setInventoryName(String inventoryName) {
+        this.inventoryName = inventoryName;
+    }
+
+    public String getPreviousInventoryName() {
+        return previousInventoryName;
+    }
+
+    public void setPreviousInventoryName(String previousInventoryName) {
+        this.previousInventoryName = previousInventoryName;
+    }
+
+    public String getKitName() {
+        return kitName;
+    }
+
+    public void setKitName(String kitName) {
+        this.kitName = kitName;
+    }
+
+    public void restoreSavedInventoryContents() {
+        if(savedInventoryContents != null){
+            player.getInventory().setContents(savedInventoryContents);
+            player.updateInventory();
+            savedInventoryContents = null;
+        }
+    }
+
+    public void saveInventoryContents() {
+        if(this.savedInventoryContents == null){
+            this.savedInventoryContents = player.getInventory().getContents();
+        }
+    }
+}

src/main/java/pk/ajneb97/model/inventory/ItemKitInventory.java

@@ -0,0 +1,86 @@
+package pk.ajneb97.model.inventory;
+
+import pk.ajneb97.model.item.KitItem;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ItemKitInventory {
+    private List<Integer> slots;
+    private String slotsString;
+    private KitItem item;
+    private String openInventory;
+    private List<String> commands;
+    private String type;
+
+    public ItemKitInventory(String slotsString, KitItem item, String openInventory, List<String> commands, String type) {
+        slots = new ArrayList<>();
+        this.slotsString = slotsString;
+        String[] slotsSep = slotsString.split(";");
+        for(int i=0;i<slotsSep.length;i++) {
+            if(slotsSep[i].contains("-")) {
+                String[] newSep = slotsSep[i].split("-");
+                int sMin = Integer.valueOf(newSep[0]);
+                int sMax = Integer.valueOf(newSep[1]);
+                for(int c=sMin;c<=sMax;c++) {
+                    slots.add(c);
+                }
+            }else {
+                slots.add(Integer.valueOf(slotsSep[i]));
+            }
+        }
+
+        this.item = item;
+        this.openInventory = openInventory;
+        this.commands = commands;
+        this.type = type;
+    }
+
+    public List<Integer> getSlots() {
+        return slots;
+    }
+
+    public void setSlots(List<Integer> slots) {
+        this.slots = slots;
+    }
+
+    public KitItem getItem() {
+        return item;
+    }
+
+    public void setItem(KitItem item) {
+        this.item = item;
+    }
+
+    public String getOpenInventory() {
+        return openInventory;
+    }
+
+    public void setOpenInventory(String openInventory) {
+        this.openInventory = openInventory;
+    }
+
+    public List<String> getCommands() {
+        return commands;
+    }
+
+    public void setCommands(List<String> commands) {
+        this.commands = commands;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public String getSlotsString() {
+        return slotsString;
+    }
+
+    public void setSlotsString(String slotsString) {
+        this.slotsString = slotsString;
+    }
+}

src/main/java/pk/ajneb97/model/inventory/KitInventory.java

@@ -0,0 +1,74 @@
+package pk.ajneb97.model.inventory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class KitInventory {
+
+    private String name;
+    private int slots;
+    private String title;
+    private List<ItemKitInventory> items;
+
+    public KitInventory(String name, int slots, String title, List<ItemKitInventory> items) {
+        this.name = name;
+        this.slots = slots;
+        this.title = title;
+        this.items = items;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getSlots() {
+        return slots;
+    }
+
+    public void setSlots(int slots) {
+        this.slots = slots;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public List<ItemKitInventory> getItems() {
+        return items;
+    }
+
+    public void setItems(List<ItemKitInventory> items) {
+        this.items = items;
+    }
+
+    public int addKitItemOnFirstEmptySlot(String kitName){
+        List<Integer> occupiedSlots = new ArrayList<>();
+        for(ItemKitInventory item : items){
+            for(int slot : item.getSlots()){
+                occupiedSlots.add(slot);
+            }
+        }
+
+        for(int i=0;i<slots;i++){
+            if(!occupiedSlots.contains(i)){
+                items.add(new ItemKitInventory(i+"",null,null,null,"kit: "+kitName));
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public void addKitItemOnSlot(String kitName,int slot){
+        List<Integer> newSlotList = new ArrayList<>();
+        newSlotList.add(slot);
+        items.add(new ItemKitInventory(slot+"",null,null,null,"kit: "+kitName));
+    }
+}

src/main/java/pk/ajneb97/model/item/KitItem.java

@@ -0,0 +1,212 @@
+package pk.ajneb97.model.item;
+
+import java.util.List;
+
+public class KitItem {
+
+    private String id;
+    private int amount;
+    private String name;
+    private List<String> lore;
+    private short durability;
+    private int customModelData;
+    private List<String> enchants;
+    private List<String> flags;
+    private List<String> bookEnchants;
+    private int color;
+    private List<String> nbt;
+    //Format:
+    //<name>;<operation>;<amount>;<uuid>;<slot>
+    private List<String> attributes;
+
+    private KitItemSkullData skullData;
+    private KitItemPotionData potionData;
+    private KitItemFireworkData fireworkData;
+    private KitItemBannerData bannerData;
+    private KitItemBookData bookData;
+    private KitItemTrimData trimData;
+
+    private boolean offhand;
+    private int previewSlot;
+
+    public KitItem(String id) {
+        this.id = id;
+        this.amount = 1;
+        this.durability = 0;
+        this.customModelData = 0;
+        this.color = 0;
+        this.previewSlot = -1;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+
+    public void setAmount(int amount) {
+        this.amount = amount;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public List<String> getLore() {
+        return lore;
+    }
+
+    public void setLore(List<String> lore) {
+        this.lore = lore;
+    }
+
+    public short getDurability() {
+        return durability;
+    }
+
+    public void setDurability(short durability) {
+        this.durability = durability;
+    }
+
+    public int getCustomModelData() {
+        return customModelData;
+    }
+
+    public void setCustomModelData(int customModelData) {
+        this.customModelData = customModelData;
+    }
+
+    public List<String> getEnchants() {
+        return enchants;
+    }
+
+    public void setEnchants(List<String> enchants) {
+        this.enchants = enchants;
+    }
+
+    public List<String> getFlags() {
+        return flags;
+    }
+
+    public void setFlags(List<String> flags) {
+        this.flags = flags;
+    }
+
+    public int getColor() {
+        return color;
+    }
+
+    public void setColor(int color) {
+        this.color = color;
+    }
+
+    public KitItemSkullData getSkullData() {
+        return skullData;
+    }
+
+    public void setSkullData(KitItemSkullData skullData) {
+        this.skullData = skullData;
+    }
+
+    public KitItemPotionData getPotionData() {
+        return potionData;
+    }
+
+    public void setPotionData(KitItemPotionData potionData) {
+        this.potionData = potionData;
+    }
+
+    public List<String> getBookEnchants() {
+        return bookEnchants;
+    }
+
+    public void setBookEnchants(List<String> bookEnchants) {
+        this.bookEnchants = bookEnchants;
+    }
+
+    public List<String> getNbt() {
+        return nbt;
+    }
+
+    public void setNbt(List<String> nbt) {
+        this.nbt = nbt;
+    }
+
+    public List<String> getAttributes() {
+        return attributes;
+    }
+
+    public void setAttributes(List<String> attributes) {
+        this.attributes = attributes;
+    }
+
+    public KitItemFireworkData getFireworkData() {
+        return fireworkData;
+    }
+
+    public void setFireworkData(KitItemFireworkData fireworkData) {
+        this.fireworkData = fireworkData;
+    }
+
+    public KitItemBannerData getBannerData() {
+        return bannerData;
+    }
+
+    public void setBannerData(KitItemBannerData bannerData) {
+        this.bannerData = bannerData;
+    }
+
+    public KitItemBookData getBookData() {
+        return bookData;
+    }
+
+    public void setBookData(KitItemBookData bookData) {
+        this.bookData = bookData;
+    }
+
+    public KitItemTrimData getTrimData() {
+        return trimData;
+    }
+
+    public void setTrimData(KitItemTrimData trimData) {
+        this.trimData = trimData;
+    }
+
+    public boolean isOffhand() {
+        return offhand;
+    }
+
+    public void setOffhand(boolean offhand) {
+        this.offhand = offhand;
+    }
+
+    public int getPreviewSlot() {
+        return previewSlot;
+    }
+
+    public void setPreviewSlot(int previewSlot) {
+        this.previewSlot = previewSlot;
+    }
+
+    public void removeOffHandFromEditInventory(){
+        //Assumes that has the lore and the nbt
+        lore.remove(lore.size()-1);
+        lore.remove(lore.size()-1);
+        for(int i=0;i<nbt.size();i++){
+            if(nbt.get(i).startsWith("playerkits_offhand")){
+                nbt.remove(i);
+                return;
+            }
+        }
+    }
+}

src/main/java/pk/ajneb97/model/item/KitItemBannerData.java

@@ -0,0 +1,26 @@
+package pk.ajneb97.model.item;
+
+import java.util.List;
+
+public class KitItemBannerData {
+
+    private List<String> patterns;
+    private String baseColor;
+    public KitItemBannerData(List<String> patterns, String baseColor) {
+        super();
+        this.patterns = patterns;
+        this.baseColor = baseColor;
+    }
+    public List<String> getPatterns() {
+        return patterns;
+    }
+    public void setPatterns(List<String> patterns) {
+        this.patterns = patterns;
+    }
+    public String getBaseColor() {
+        return baseColor;
+    }
+    public void setBaseColor(String baseColor) {
+        this.baseColor = baseColor;
+    }
+}

src/main/java/pk/ajneb97/model/item/KitItemBookData.java

@@ -0,0 +1,42 @@
+package pk.ajneb97.model.item;
+
+import java.util.List;
+
+public class KitItemBookData {
+
+    private List<String> pages;
+    private String author;
+    private String generation;
+    private String title;
+    public KitItemBookData(List<String> pages, String author, String generation, String title) {
+        super();
+        this.pages = pages;
+        this.author = author;
+        this.generation = generation;
+        this.title = title;
+    }
+    public List<String> getPages() {
+        return pages;
+    }
+    public void setPages(List<String> pages) {
+        this.pages = pages;
+    }
+    public String getAuthor() {
+        return author;
+    }
+    public void setAuthor(String author) {
+        this.author = author;
+    }
+    public String getGeneration() {
+        return generation;
+    }
+    public void setGeneration(String generation) {
+        this.generation = generation;
+    }
+    public String getTitle() {
+        return title;
+    }
+    public void setTitle(String title) {
+        this.title = title;
+    }
+}

src/main/java/pk/ajneb97/model/item/KitItemFireworkData.java

@@ -0,0 +1,34 @@
+package pk.ajneb97.model.item;
+
+import java.util.List;
+
+public class KitItemFireworkData {
+
+    private List<String> fireworkRocketEffects;
+    private String fireworkStarEffect;
+    private int fireworkPower;
+    public KitItemFireworkData(List<String> fireworkRocketEffects, String fireworkStarEffect, int fireworkPower) {
+        super();
+        this.fireworkRocketEffects = fireworkRocketEffects;
+        this.fireworkStarEffect = fireworkStarEffect;
+        this.fireworkPower = fireworkPower;
+    }
+    public List<String> getFireworkRocketEffects() {
+        return fireworkRocketEffects;
+    }
+    public void setFireworkRocketEffects(List<String> fireworkRocketEffects) {
+        this.fireworkRocketEffects = fireworkRocketEffects;
+    }
+    public String getFireworkStarEffect() {
+        return fireworkStarEffect;
+    }
+    public void setFireworkStarEffect(String fireworkStarEffect) {
+        this.fireworkStarEffect = fireworkStarEffect;
+    }
+    public int getFireworkPower() {
+        return fireworkPower;
+    }
+    public void setFireworkPower(int fireworkPower) {
+        this.fireworkPower = fireworkPower;
+    }
+}

src/main/java/pk/ajneb97/model/item/KitItemPotionData.java

@@ -0,0 +1,51 @@
+package pk.ajneb97.model.item;
+
+import java.util.List;
+
+public class KitItemPotionData {
+
+    private boolean upgraded;
+    private boolean extended;
+    private String potionType;
+    private int potionColor;
+    private List<String> potionEffects;
+    public KitItemPotionData(boolean upgraded, boolean extended, String potionType, int potionColor,
+                                  List<String> potionEffects) {
+        super();
+        this.upgraded = upgraded;
+        this.extended = extended;
+        this.potionType = potionType;
+        this.potionColor = potionColor;
+        this.potionEffects = potionEffects;
+    }
+    public boolean isUpgraded() {
+        return upgraded;
+    }
+    public void setUpgraded(boolean upgraded) {
+        this.upgraded = upgraded;
+    }
+    public boolean isExtended() {
+        return extended;
+    }
+    public void setExtended(boolean extended) {
+        this.extended = extended;
+    }
+    public String getPotionType() {
+        return potionType;
+    }
+    public void setPotionType(String potionType) {
+        this.potionType = potionType;
+    }
+    public int getPotionColor() {
+        return potionColor;
+    }
+    public void setPotionColor(int potionColor) {
+        this.potionColor = potionColor;
+    }
+    public List<String> getPotionEffects() {
+        return potionEffects;
+    }
+    public void setPotionEffects(List<String> potionEffects) {
+        this.potionEffects = potionEffects;
+    }
+}

src/main/java/pk/ajneb97/model/item/KitItemSkullData.java

@@ -0,0 +1,32 @@
+package pk.ajneb97.model.item;
+
+public class KitItemSkullData {
+
+    private String owner;
+    private String texture;
+    private String id;
+    public KitItemSkullData(String owner, String texture, String id) {
+        super();
+        this.owner = owner;
+        this.texture = texture;
+        this.id = id;
+    }
+    public String getOwner() {
+        return owner;
+    }
+    public void setOwner(String owner) {
+        this.owner = owner;
+    }
+    public String getTexture() {
+        return texture;
+    }
+    public void setTexture(String texture) {
+        this.texture = texture;
+    }
+    public String getId() {
+        return id;
+    }
+    public void setId(String id) {
+        this.id = id;
+    }
+}

src/main/java/pk/ajneb97/model/item/KitItemTrimData.java

@@ -0,0 +1,28 @@
+package pk.ajneb97.model.item;
+
+public class KitItemTrimData {
+
+	private String pattern;
+	private String material;
+
+	public KitItemTrimData(String pattern, String material) {
+		this.pattern = pattern;
+		this.material = material;
+	}
+
+	public String getPattern() {
+		return pattern;
+	}
+
+	public void setPattern(String pattern) {
+		this.pattern = pattern;
+	}
+
+	public String getMaterial() {
+		return material;
+	}
+
+	public void setMaterial(String material) {
+		this.material = material;
+	}
+}

src/main/java/pk/ajneb97/tasks/InventoryUpdateTaskManager.java

@@ -0,0 +1,58 @@
+package pk.ajneb97.tasks;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.scheduler.BukkitRunnable;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.*;
+import pk.ajneb97.model.inventory.InventoryPlayer;
+import pk.ajneb97.utils.ItemUtils;
+
+import java.util.ArrayList;
+
+public class InventoryUpdateTaskManager {
+
+    private PlayerKits2 plugin;
+    public InventoryUpdateTaskManager(PlayerKits2 plugin){
+        this.plugin = plugin;
+    }
+
+    public void start(){
+        new BukkitRunnable(){
+            @Override
+            public void run() {
+                execute();
+            }
+        }.runTaskTimerAsynchronously(plugin,0L,20L);
+    }
+
+    public void execute(){
+        InventoryManager inventoryManager = plugin.getInventoryManager();
+        KitsManager kitsManager = plugin.getKitsManager();
+        MessagesManager msgManager = plugin.getMessagesManager();
+        PlayerDataManager playerDataManager = plugin.getPlayerDataManager();
+        KitItemManager kitItemManager = plugin.getKitItemManager();
+
+        ArrayList<InventoryPlayer> players = inventoryManager.getPlayers();
+        for(InventoryPlayer player : players){
+            Inventory inv = player.getPlayer().getOpenInventory().getTopInventory();
+            if(inv == null){
+                continue;
+            }
+            ItemStack[] contents = inv.getContents();
+            for(int i=0;i<contents.length;i++){
+                ItemStack item = contents[i];
+                if(item == null || item.getType().equals(Material.AIR)){
+                    continue;
+                }
+
+                String kitName = ItemUtils.getTagStringItem(plugin,item,"playerkits_kit");
+                if(kitName != null){
+                    inventoryManager.setKit(kitName,player.getPlayer(),inv,i,kitsManager,
+                            playerDataManager,kitItemManager,msgManager);
+                }
+            }
+        }
+    }
+}

src/main/java/pk/ajneb97/tasks/PlayerDataSaveTask.java

@@ -0,0 +1,38 @@
+package pk.ajneb97.tasks;
+
+import org.bukkit.scheduler.BukkitRunnable;
+import pk.ajneb97.PlayerKits2;
+
+public class PlayerDataSaveTask {
+
+	private PlayerKits2 plugin;
+	private boolean end;
+	public PlayerDataSaveTask(PlayerKits2 plugin) {
+		this.plugin = plugin;
+		this.end = false;
+	}
+	
+	public void end() {
+		end = true;
+	}
+	
+	public void start(int minutes) {
+		long ticks = minutes*60*20;
+		
+		new BukkitRunnable() {
+			@Override
+			public void run() {
+				if(end) {
+					this.cancel();
+				}else {
+					execute();
+				}
+			}
+			
+		}.runTaskTimerAsynchronously(plugin, 0L, ticks);
+	}
+	
+	public void execute() {
+		plugin.getConfigsManager().getPlayersConfigManager().saveConfigs();
+	}
+}

src/main/java/pk/ajneb97/utils/ActionUtils.java

@@ -0,0 +1,110 @@
+package pk.ajneb97.utils;
+
+import org.bukkit.*;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Firework;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.meta.FireworkMeta;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.libs.actionbar.ActionBarAPI;
+import pk.ajneb97.libs.titles.TitleAPI;
+import pk.ajneb97.managers.MessagesManager;
+
+import java.util.ArrayList;
+
+public class ActionUtils {
+
+    public static void consoleCommand(String actionLine){
+        ConsoleCommandSender sender = Bukkit.getConsoleSender();
+        Bukkit.dispatchCommand(sender, actionLine);
+    }
+
+    public static void playerCommand(Player player, String actionLine){
+        player.performCommand(actionLine);
+    }
+
+    public static void playSound(Player player,String actionLine){
+        String[] sep = actionLine.split(";");
+        Sound sound = null;
+        int volume = 0;
+        float pitch = 0;
+        try {
+            sound = Sound.valueOf(sep[0]);
+            volume = Integer.valueOf(sep[1]);
+            pitch = Float.valueOf(sep[2]);
+        }catch(Exception e ) {
+            Bukkit.getConsoleSender().sendMessage(PlayerKits2.prefix+
+                    MessagesManager.getColoredMessage("&7Sound Name: &c"+sep[0]+" &7is not valid. Change it in the config!"));
+            return;
+        }
+
+        player.playSound(player.getLocation(), sound, volume, pitch);
+    }
+
+    public static void actionbar(Player player, String actionLine, PlayerKits2 plugin){
+        String[] sep = actionLine.split(";");
+        String text = sep[0];
+        int duration = Integer.valueOf(sep[1]);
+        ActionBarAPI.sendActionBar(player,text,duration,plugin);
+    }
+
+    public static void title(Player player,String actionLine){
+        String[] sep = actionLine.split(";");
+        int fadeIn = Integer.valueOf(sep[0]);
+        int stay = Integer.valueOf(sep[1]);
+        int fadeOut = Integer.valueOf(sep[2]);
+
+        String title = sep[3];
+        String subtitle = sep[4];
+        if(title.equals("none")) {
+            title = "";
+        }
+        if(subtitle.equals("none")) {
+            subtitle = "";
+        }
+        TitleAPI.sendTitle(player,fadeIn,stay,fadeOut,title,subtitle);
+    }
+
+    public static void firework(Player player,String actionLine){
+        ArrayList<Color> colors = new ArrayList<Color>();
+        FireworkEffect.Type type = null;
+        ArrayList<Color> fadeColors = new ArrayList<Color>();
+        int power = 0;
+
+        String[] sep = actionLine.split(" ");
+        for(String s : sep) {
+            if(s.startsWith("colors:")) {
+                s = s.replace("colors:", "");
+                String[] colorsSep = s.split(",");
+                for(String colorSep : colorsSep) {
+                    colors.add(OtherUtils.getFireworkColorFromName(colorSep));
+                }
+            }else if(s.startsWith("type:")) {
+                s = s.replace("type:", "");
+                type = FireworkEffect.Type.valueOf(s);
+            }else if(s.startsWith("fade:")) {
+                s = s.replace("fade:", "");
+                String[] colorsSep = s.split(",");
+                for(String colorSep : colorsSep) {
+                    fadeColors.add(OtherUtils.getFireworkColorFromName(colorSep));
+                }
+            }else if(s.startsWith("power:")) {
+                s = s.replace("power:", "");
+                power = Integer.valueOf(s);
+            }
+        }
+
+        Location location = player.getLocation();
+        Firework firework = (Firework) location.getWorld().spawnEntity(location, EntityType.FIREWORK);
+        FireworkMeta fireworkMeta = firework.getFireworkMeta();
+        FireworkEffect effect = FireworkEffect.builder().flicker(false)
+                .withColor(colors)
+                .with(type)
+                .withFade(fadeColors)
+                .build();
+        fireworkMeta.addEffect(effect);
+        fireworkMeta.setPower(power);
+        firework.setFireworkMeta(fireworkMeta);
+    }
+}

src/main/java/pk/ajneb97/utils/InventoryItem.java

@@ -0,0 +1,76 @@
+package pk.ajneb97.utils;
+
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import pk.ajneb97.managers.MessagesManager;
+import pk.ajneb97.model.item.KitItemSkullData;
+
+import java.util.List;
+
+public class InventoryItem {
+
+	private Inventory inventory;
+	private int slot;
+	private ItemStack item;
+	private ItemMeta meta;
+	private String headTexture;
+	
+	public InventoryItem(Inventory inventory, int slot, Material material) {
+		this.inventory = inventory;
+		this.item = new ItemStack(material);
+		this.meta = item.getItemMeta();
+		this.slot = slot;
+	}
+	
+	@SuppressWarnings("deprecation")
+	public InventoryItem dataValue(short datavalue) {
+		item.setDurability(datavalue);
+		return this;
+	}
+	
+	public InventoryItem amount(int amount) {
+		item.setAmount(amount);
+		return this;
+	}
+	
+	public InventoryItem name(String name) {
+		meta.setDisplayName(MessagesManager.getColoredMessage(name));
+		return this;
+	}
+	
+	public InventoryItem lore(List<String> lore) {
+		for(int i=0;i<lore.size();i++) {
+			lore.set(i, MessagesManager.getColoredMessage(lore.get(i)));
+		}
+		meta.setLore(lore);
+		return this;
+	}
+	
+	public InventoryItem enchanted(boolean enchanted) {
+		if(enchanted) {
+			meta.addEnchant(Enchantment.ARROW_DAMAGE, 1, true);
+			meta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
+		}
+		return this;
+	}
+
+	public InventoryItem setSkull(String texture){
+		if(OtherUtils.isLegacy()){
+			item.setDurability((short) 3);
+		}
+		headTexture = texture;
+		return this;
+	}
+	
+	public void ready() {
+		item.setItemMeta(meta);
+		if(headTexture != null){
+			ItemUtils.setSkullData(item,new KitItemSkullData(null,headTexture,null),null);
+		}
+		inventory.setItem(slot, item);
+	}
+}

src/main/java/pk/ajneb97/utils/ItemUtils.java

@@ -0,0 +1,619 @@
+package pk.ajneb97.utils;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import org.bukkit.*;
+import org.bukkit.FireworkEffect.Type;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.attribute.AttributeModifier;
+import org.bukkit.block.Banner;
+import org.bukkit.block.banner.Pattern;
+import org.bukkit.block.banner.PatternType;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.*;
+import org.bukkit.inventory.meta.BookMeta.Generation;
+import org.bukkit.inventory.meta.trim.ArmorTrim;
+import org.bukkit.potion.PotionData;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.potion.PotionType;
+
+import com.google.common.collect.Multimap;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import com.mojang.authlib.properties.PropertyMap;
+import net.md_5.bungee.api.chat.BaseComponent;
+import net.md_5.bungee.chat.ComponentSerializer;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.model.item.*;
+
+public class ItemUtils {
+
+
+	@SuppressWarnings("deprecation")
+	public static ItemStack createItemFromID(String id) {
+		String[] idsplit = new String[2];
+		int DataValue = 0;
+		ItemStack stack = null;
+		if(id.contains(":")){
+			  idsplit = id.split(":");
+			  String stringDataValue = idsplit[1];
+			  DataValue = Integer.valueOf(stringDataValue);
+			  Material mat = Material.getMaterial(idsplit[0].toUpperCase()); 
+			  stack = new ItemStack(mat,1,(short)DataValue);	             	  
+		}else{
+			  Material mat = Material.getMaterial(id.toUpperCase());
+			  stack = new ItemStack(mat,1);	  			  
+		}
+		return stack;
+	}
+	
+	public static ItemStack setTagStringItem(PlayerKits2 plugin, ItemStack item, String key, String value) {
+		return plugin.getNmsManager().setTagStringItem(item,key,value);
+	}
+	
+	public static String getTagStringItem(PlayerKits2 plugin, ItemStack item, String key) {
+		if(item == null || item.getType().equals(Material.AIR)){
+			return null;
+		}
+		return plugin.getNmsManager().getTagStringItem(item,key);
+	}
+
+	public static ItemStack removeTagItem(PlayerKits2 plugin, ItemStack item, String key) {
+		return plugin.getNmsManager().removeTagItem(item,key);
+	}
+	
+	public static List<String> getNBT(PlayerKits2 plugin, ItemStack item){
+		return plugin.getNmsManager().getNBT(item);
+	}
+	
+	public static ItemStack setNBT(PlayerKits2 plugin, ItemStack item, List<String> nbtList){
+		return plugin.getNmsManager().setNBT(item,nbtList);
+	}
+	
+	public static KitItemSkullData getSkullData(ItemStack item) {
+		KitItemSkullData kitItemSkullData = null;
+		String owner = null;
+		String texture = null;
+		String id = null;
+		
+		String typeName = item.getType().name();
+		if(!typeName.equals("PLAYER_HEAD") && !typeName.equals("SKULL_ITEM")) {
+			return null;
+		}
+		
+		SkullMeta skullMeta = (SkullMeta) item.getItemMeta();
+		Field profileField;
+		try {
+			profileField = skullMeta.getClass().getDeclaredField("profile");
+			profileField.setAccessible(true);
+			try {
+				GameProfile gameProfile = (GameProfile) profileField.get(skullMeta);
+				if(gameProfile != null && gameProfile.getProperties() != null) {
+					PropertyMap propertyMap = gameProfile.getProperties();
+					owner = gameProfile.getName();
+					if(gameProfile.getId() != null) {
+						id = gameProfile.getId().toString();
+					}
+					for(Property p : propertyMap.values()) {
+						if(p.getName().equals("textures")) {
+							texture = p.getValue();
+						}
+					}
+				}
+			} catch (IllegalArgumentException | IllegalAccessException e) {
+				e.printStackTrace();
+			}
+		} catch (NoSuchFieldException | SecurityException e) {
+			e.printStackTrace();
+		}	
+		
+		if(texture != null || id != null || owner != null) {
+			kitItemSkullData = new KitItemSkullData(owner,texture,id);
+		}
+		
+		return kitItemSkullData;
+	}
+	
+	@SuppressWarnings("deprecation")
+	public static void setSkullData(ItemStack item, KitItemSkullData skullData, Player player){
+		String typeName = item.getType().name();
+		if(!typeName.equals("PLAYER_HEAD") && !typeName.equals("SKULL_ITEM")) {
+			return;
+		}
+		
+		if(skullData == null) {
+			return;
+		}
+		
+		String texture = skullData.getTexture();
+		String owner = skullData.getOwner();
+		if(owner != null && player != null) {
+			owner = owner.replace("%player%", player.getName());
+		}
+		String id = skullData.getId();
+        SkullMeta skullMeta = (SkullMeta) item.getItemMeta();
+        if(texture == null && owner != null) {
+        	skullMeta.setOwner(owner);
+        	item.setItemMeta(skullMeta);
+        	return;
+        }
+        
+        GameProfile profile = null;
+        if(id == null) {
+        	profile = new GameProfile(UUID.randomUUID(), owner);
+        }else {
+        	profile = new GameProfile(UUID.fromString(id), owner);
+        }
+        profile.getProperties().put("textures", new Property("textures", texture));
+
+        try {
+            Field profileField = skullMeta.getClass().getDeclaredField("profile");
+            profileField.setAccessible(true);
+            profileField.set(skullMeta, profile);
+        } catch (IllegalArgumentException|NoSuchFieldException|SecurityException|IllegalAccessException error) {
+            error.printStackTrace();
+        }
+        item.setItemMeta(skullMeta);
+	}
+	
+	public static KitItemPotionData getPotionData(ItemStack item) {
+		KitItemPotionData potionData = null;
+		List<String> potionEffectsList = new ArrayList<String>();
+		boolean upgraded = false;
+		boolean extended = false;
+		String potionType = null;
+		int potionColor = 0;
+		
+		String typeName = item.getType().name();
+		if(!typeName.contains("POTION") && !typeName.equals("TIPPED_ARROW")) {
+			return null;
+		}
+		
+		if(!(item.getItemMeta() instanceof PotionMeta)) {
+			return null;
+		}
+		
+		PotionMeta meta = (PotionMeta) item.getItemMeta();
+		if(meta.hasCustomEffects()) {
+			List<PotionEffect> potionEffects = meta.getCustomEffects();
+			for(int i=0;i<potionEffects.size();i++) {
+				String type = potionEffects.get(i).getType().getName();
+				int amplifier = potionEffects.get(i).getAmplifier();
+				int duration = potionEffects.get(i).getDuration();
+				potionEffectsList.add(type+";"+amplifier+";"+duration);
+			}
+		}
+		if(!Bukkit.getVersion().contains("1.8")) {
+			if(meta.hasColor()) {
+				potionColor = meta.getColor().asRGB();
+			}
+			PotionData basePotionData = meta.getBasePotionData();
+			extended = basePotionData.isExtended();
+			upgraded = basePotionData.isUpgraded();
+			potionType = basePotionData.getType().name();
+		}
+		
+		potionData = new KitItemPotionData(upgraded,extended,potionType,potionColor,potionEffectsList);
+		
+		return potionData;
+	}
+	
+	public static void setPotionData(ItemStack item,KitItemPotionData potionData){
+		String typeName = item.getType().name();
+		if(!typeName.contains("POTION") && !typeName.equals("TIPPED_ARROW")) {
+			return;
+		}
+		
+		if(potionData == null) {
+			return;
+		}
+		
+		if(!(item.getItemMeta() instanceof PotionMeta)) {
+			return;
+		}
+		
+		PotionMeta meta = (PotionMeta) item.getItemMeta();
+		
+		List<String> potionEffects = potionData.getPotionEffects();
+		if(potionEffects != null) {
+			for(int i=0;i<potionEffects.size();i++) {
+				String[] sep = potionEffects.get(i).split(";");
+				String type = sep[0];
+				int amplifier = Integer.valueOf(sep[1]);
+				int duration = Integer.valueOf(sep[2]);
+				meta.addCustomEffect(new PotionEffect(PotionEffectType.getByName(type),duration,amplifier), false);
+			}
+		}
+		
+		if(!Bukkit.getVersion().contains("1.8")) {
+			PotionData basePotionData = new PotionData(
+					PotionType.valueOf(potionData.getPotionType()),
+					potionData.isExtended(),
+					potionData.isUpgraded());
+			meta.setBasePotionData(basePotionData);
+			
+			int color = potionData.getPotionColor();
+			if(color != 0) {
+				meta.setColor(Color.fromRGB(color));
+			}
+		}
+		
+		item.setItemMeta(meta);
+	}
+	
+	public static KitItemBannerData getBannerData(ItemStack item) {
+		KitItemBannerData bannerData = null;
+		List<String> bannerPatterns = new ArrayList<String>();
+		String baseColor = null;
+		
+		List<Pattern> patterns = new ArrayList<Pattern>();
+		
+		String typeName = item.getType().name();
+		if(typeName.contains("BANNER") || typeName.contains("PATTERN")) {
+			if(item.getItemMeta() instanceof BannerMeta) {
+				BannerMeta meta = (BannerMeta) item.getItemMeta();
+				patterns = meta.getPatterns();
+			}
+		}else if(typeName.equals("SHIELD")) {
+			BlockStateMeta meta = (BlockStateMeta) item.getItemMeta();
+			if(meta.hasBlockState()) {
+				Banner banner = (Banner) meta.getBlockState();
+				patterns = banner.getPatterns();
+				if(OtherUtils.isLegacy()) {
+					baseColor = banner.getBaseColor().name();
+				}else {
+					baseColor = banner.getType().name();
+				}
+			}
+		}else {
+			return null;
+		}
+		
+		for(Pattern p : patterns) {
+			bannerPatterns.add(p.getColor().name()+";"+p.getPattern().name());
+		}
+		
+		if(bannerPatterns.isEmpty() && baseColor == null) {
+			return null;
+		}
+		
+		bannerData = new KitItemBannerData(bannerPatterns,baseColor);
+		return bannerData;
+	}
+	
+	public static void setBannerData(ItemStack item,KitItemBannerData bannerData){
+		String typeName = item.getType().name();
+
+		if(bannerData == null) {
+			return;
+		}
+		
+		List<String> bannerPatterns = bannerData.getPatterns();
+		String baseColor = bannerData.getBaseColor();
+		
+		if(typeName.contains("BANNER") || typeName.contains("PATTERN")) {
+			BannerMeta meta = (BannerMeta) item.getItemMeta();
+			if(bannerPatterns != null) {
+				for(String pattern : bannerPatterns) {
+					String[] patternSplit = pattern.split(";");
+					String patternColor = patternSplit[0];
+					String patternName = patternSplit[1];
+					meta.addPattern(new Pattern(DyeColor.valueOf(patternColor),PatternType.valueOf(patternName)));
+				}
+				item.setItemMeta(meta);
+			}
+		}else if(typeName.equals("SHIELD")) {
+			BlockStateMeta meta = (BlockStateMeta) item.getItemMeta();
+			Banner banner = (Banner) meta.getBlockState();
+			if(OtherUtils.isLegacy()) {
+				banner.setBaseColor(DyeColor.valueOf(baseColor));
+			}else {
+				String fixedColor = baseColor.replace("_BANNER", "");
+				banner.setBaseColor(DyeColor.valueOf(fixedColor));
+			}
+			if(bannerPatterns != null) {
+				for(String pattern : bannerPatterns) {
+					String[] patternSplit = pattern.split(";");
+					String patternColor = patternSplit[0];
+					String patternName = patternSplit[1];
+					banner.addPattern(new Pattern(DyeColor.valueOf(patternColor),PatternType.valueOf(patternName)));
+				}
+			}
+			banner.update();
+			meta.setBlockState(banner);
+			item.setItemMeta(meta);
+		}
+	}
+	
+	public static KitItemFireworkData getFireworkData(ItemStack item) {
+		KitItemFireworkData fireworkData = null;
+		
+		List<String> fireworkRocketEffects = new ArrayList<String>();
+		String fireworkStarEffect = null;
+		int fireworkPower = 0;
+		
+		String typeName = item.getType().name();
+		boolean isFireworkCharge = false;
+		List<FireworkEffect> effects = new ArrayList<FireworkEffect>();
+		
+		if(typeName.equals("FIREWORK") || typeName.equals("FIREWORK_ROCKET")) {
+			FireworkMeta meta = (FireworkMeta) item.getItemMeta();
+			fireworkPower = meta.getPower();
+			effects = meta.getEffects();
+		}else if(typeName.equals("FIREWORK_STAR") || typeName.equals("FIREWORK_CHARGE")) {
+			FireworkEffectMeta meta = (FireworkEffectMeta) item.getItemMeta();
+			FireworkEffect effect = meta.getEffect();
+			effects.add(effect);
+			isFireworkCharge = true;
+		}else {
+			return null;
+		}
+		
+		for(FireworkEffect e : effects) {
+			if(e == null) {
+				continue;
+			}
+			String line = e.getType().name()+";";
+			List<Color> colors = e.getColors();
+			String colorsLine = "";
+			for(int i=0;i<colors.size();i++) {
+				if(colors.size() <= (i+1)) {
+					colorsLine = colorsLine+colors.get(i).asRGB()+";";
+				}else {
+					colorsLine = colorsLine+colors.get(i).asRGB()+",";
+				}
+			}
+			List<Color> fadeColors = e.getFadeColors();
+			String fadeColorsLine = "";
+			for(int i=0;i<fadeColors.size();i++) {
+				if(fadeColors.size() <= (i+1)) {
+					fadeColorsLine = fadeColorsLine+fadeColors.get(i).asRGB();
+				}else {
+					fadeColorsLine = fadeColorsLine+fadeColors.get(i).asRGB()+",";
+				}
+			}
+			line = line+colorsLine+fadeColorsLine+";"+e.hasFlicker()+";"+e.hasTrail();
+			
+			if(isFireworkCharge) {
+				fireworkStarEffect = line;
+				break;
+			}
+			
+			fireworkRocketEffects.add(line);
+		}
+		
+		fireworkData = new KitItemFireworkData(fireworkRocketEffects,fireworkStarEffect,fireworkPower);
+		
+		return fireworkData;
+	}
+	
+	public static void setFireworkData(ItemStack item,KitItemFireworkData fireworkData){
+		String typeName = item.getType().name();
+
+		if(fireworkData == null) {
+			return;
+		}
+		
+		int power = fireworkData.getFireworkPower();
+		List<String> rocketEffects = fireworkData.getFireworkRocketEffects();
+		String starEffect = fireworkData.getFireworkStarEffect();
+		
+		if(typeName.equals("FIREWORK") || typeName.equals("FIREWORK_ROCKET")) {
+			FireworkMeta meta = (FireworkMeta) item.getItemMeta();
+			if(rocketEffects != null) {
+				for(int i=0;i<rocketEffects.size();i++) {
+					FireworkEffect effect = getFireworkEffect(rocketEffects.get(i));
+					meta.addEffect(effect);
+				}
+			}
+			meta.setPower(power);
+			item.setItemMeta(meta);
+		}else if(typeName.equals("FIREWORK_STAR") || typeName.equals("FIREWORK_CHARGE")) {
+			FireworkEffectMeta meta = (FireworkEffectMeta) item.getItemMeta();
+			if(starEffect != null) {
+				meta.setEffect(getFireworkEffect(starEffect));
+			}
+			item.setItemMeta(meta);
+		}
+	}
+	
+	private static FireworkEffect getFireworkEffect(String line) {
+		String[] sep = line.split(";");
+		String type = sep[0];
+		String[] colors = sep[1].split(",");
+		List<Color> colorsList = new ArrayList<Color>();
+		for(int c=0;c<colors.length;c++) {
+			colorsList.add(Color.fromRGB(Integer.valueOf(colors[c])));
+		}
+		List<Color> fadeColorsList = new ArrayList<Color>();
+		if(!sep[2].equals("")) {
+			String[] fadeColors = sep[2].split(",");
+			for(int c=0;c<fadeColors.length;c++) {
+				fadeColorsList.add(Color.fromRGB(Integer.valueOf(fadeColors[c])));
+			} 
+		}
+
+		boolean flicker = Boolean.valueOf(sep[3]);
+		boolean trail = Boolean.valueOf(sep[4]);
+		return FireworkEffect.builder().flicker(flicker).trail(trail).with(Type.valueOf(type))
+				.withColor(colorsList).withFade(fadeColorsList).build();
+	}
+	
+	public static List<String> getAttributes(PlayerKits2 plugin, ItemStack item){
+		if(OtherUtils.isLegacy()) {
+			return plugin.getNmsManager().getAttributes(item);
+		}else {
+			//1.13+
+			ItemMeta meta = item.getItemMeta();
+			if(meta.hasAttributeModifiers()) {
+				Multimap<Attribute,AttributeModifier> attributes = meta.getAttributeModifiers();
+				Set<Attribute> set = attributes.keySet();
+
+				List<String> attributeList = new ArrayList<String>();
+				for(Attribute a : set) {
+					Collection<AttributeModifier> listaModifiers = attributes.get(a);
+					for(AttributeModifier m : listaModifiers) {
+						String line = a.name()+";"+m.getOperation().name()+";"+m.getAmount()+";"+UUID.randomUUID().toString();
+						if(m.getSlot() != null) {
+							line=line+";"+m.getSlot().name();
+						}
+						attributeList.add(line);
+					}
+				}
+				
+				return attributeList;
+			}
+		}
+		return null;
+	}
+	
+	public static ItemStack setAttributes(PlayerKits2 plugin, ItemStack item, List<String> attributes) {
+		if(attributes == null) {
+			return item;
+		}
+		
+		if(OtherUtils.isLegacy()) {
+			return plugin.getNmsManager().setAttributes(item,attributes);
+		}else {
+			//1.13+
+			ItemMeta meta = item.getItemMeta();
+			for(String a : attributes) {
+				String[] sep = a.split(";");
+				String attribute = sep[0];
+				AttributeModifier.Operation op = AttributeModifier.Operation.valueOf(sep[1]);
+				double amount = Double.valueOf(sep[2]);
+				UUID uuid = UUID.fromString(sep[3]);
+				AttributeModifier modifier = null;
+				if(sep.length >= 5) {
+					EquipmentSlot slot = EquipmentSlot.valueOf(sep[4]);
+					modifier = new AttributeModifier(uuid,attribute,amount,op,slot);
+				}else {
+					modifier = new AttributeModifier(uuid,attribute,amount,op);
+				}
+
+				meta.addAttributeModifier(Attribute.valueOf(attribute), modifier);
+			}
+			
+			item.setItemMeta(meta);
+		}
+		return item;
+	}
+	
+	public static KitItemBookData getBookData(ItemStack item){
+		KitItemBookData bookData = null;
+		String typeName = item.getType().name();
+		
+		List<String> pages = new ArrayList<String>();
+		String author = null;
+		String generation = null;
+		String title = null;
+
+		if(typeName.equals("WRITTEN_BOOK")) {
+			BookMeta meta = (BookMeta) item.getItemMeta();
+			
+			author = meta.getAuthor();
+			title = meta.getTitle();
+			
+			if(!Bukkit.getVersion().contains("1.12") && OtherUtils.isLegacy()) {
+				pages = new ArrayList<String>(meta.getPages());
+			}else {
+				if(meta.getGeneration() != null) {
+					generation = meta.getGeneration().name();
+				}
+				for(BaseComponent[] page : meta.spigot().getPages()) {
+					pages.add(ComponentSerializer.toString(page));
+				}
+			}
+			
+			bookData = new KitItemBookData(pages,author,generation,title);
+			return bookData;
+		}else {
+			return null;
+		}
+	}
+	
+	public static void setBookData(ItemStack item,KitItemBookData bookData){
+		String typeName = item.getType().name();
+
+		if(bookData == null) {
+			return;
+		}
+		
+		String author = bookData.getAuthor();
+		String generation = bookData.getGeneration();
+		String title = bookData.getTitle();
+		List<String> pages = bookData.getPages();
+		
+		if(typeName.equals("WRITTEN_BOOK")) {
+			BookMeta meta = (BookMeta) item.getItemMeta();
+			if(!Bukkit.getVersion().contains("1.12") && OtherUtils.isLegacy()) {
+				meta.setPages(new ArrayList<String>(pages));
+			}else {
+				ArrayList<BaseComponent[]> pagesBaseComponent = new ArrayList<BaseComponent[]>();
+				for(String page : pages) {
+					pagesBaseComponent.add(ComponentSerializer.parse(page));
+				}
+				meta.spigot().setPages(pagesBaseComponent);
+				if(generation != null) {
+					meta.setGeneration(Generation.valueOf(generation));
+				}
+			}
+			meta.setAuthor(author);
+			meta.setTitle(title);
+			
+			item.setItemMeta(meta);
+		}
+	}
+
+	public static KitItemTrimData getArmorTrimData(ItemStack item) {
+		if(!OtherUtils.isTrimNew()) {
+			return null;
+		}
+
+		String armorTrimPattern = null;
+		String armorTrimMaterial = null;
+		if(item.getItemMeta() instanceof ArmorMeta) {
+			ArmorMeta meta = (ArmorMeta) item.getItemMeta();
+			if(meta.hasTrim()){
+				ArmorTrim armorTrim = meta.getTrim();
+				armorTrimPattern = armorTrim.getPattern().getKey().getKey();
+				armorTrimMaterial = armorTrim.getMaterial().getKey().getKey();
+			}else{
+				return null;
+			}
+		}else{
+			return null;
+		}
+
+		return new KitItemTrimData(armorTrimPattern,armorTrimMaterial);
+	}
+
+	public static void setArmorTrimData(ItemStack item,KitItemTrimData trimData){
+		if(trimData == null || !OtherUtils.isTrimNew()) {
+			return;
+		}
+
+		String pattern = trimData.getPattern();
+		String material = trimData.getMaterial();
+
+		if(item.getItemMeta() instanceof ArmorMeta) {
+			ArmorMeta meta = (ArmorMeta) item.getItemMeta();
+			if(pattern != null && material != null){
+				ArmorTrim armorTrim = new ArmorTrim(
+						Registry.TRIM_MATERIAL.get(NamespacedKey.minecraft(material.toLowerCase())),
+						Registry.TRIM_PATTERN.get(NamespacedKey.minecraft(pattern.toLowerCase()))
+				);
+				meta.setTrim(armorTrim);
+				item.setItemMeta(meta);
+			}
+		}
+	}
+}

src/main/java/pk/ajneb97/utils/OtherUtils.java

@@ -0,0 +1,103 @@
+package pk.ajneb97.utils;
+import me.clip.placeholderapi.PlaceholderAPI;
+import org.bukkit.Bukkit;
+import org.bukkit.Color;
+import org.bukkit.entity.Player;
+import pk.ajneb97.PlayerKits2;
+import pk.ajneb97.managers.MessagesManager;
+
+import java.util.ArrayList;
+
+public class OtherUtils {
+
+    public static boolean isNew() {
+        if(Bukkit.getVersion().contains("1.16") || Bukkit.getVersion().contains("1.17")
+                || Bukkit.getVersion().contains("1.18") || Bukkit.getVersion().contains("1.19")
+                || Bukkit.getVersion().contains("1.20")) {
+            return true;
+        }else {
+            return false;
+        }
+    }
+
+    public static boolean isLegacy() {
+        if(Bukkit.getVersion().contains("1.13") || Bukkit.getVersion().contains("1.14") ||
+                Bukkit.getVersion().contains("1.15") || isNew()) {
+            return false;
+        }else {
+            return true;
+        }
+    }
+
+    // 1.20+
+    public static boolean isTrimNew() {
+        if(Bukkit.getVersion().contains("1.20")) {
+            return true;
+        }else {
+            return false;
+        }
+    }
+
+    public static String getTime(long seconds, MessagesManager msgManager) {
+        long totalMinWait = seconds/60;
+        long totalHourWait = totalMinWait/60;
+        long totalDayWait = totalHourWait/24;
+        String time = "";
+        if(seconds > 59){
+            seconds = seconds - 60*totalMinWait;
+        }
+        if(seconds > 0) {
+            time = seconds+msgManager.getTimeSeconds();
+        }
+        if(totalMinWait > 59){
+            totalMinWait = totalMinWait - 60*totalHourWait;
+        }
+        if(totalMinWait > 0){
+            time = totalMinWait+msgManager.getTimeMinutes()+" "+time;
+        }
+        if(totalHourWait > 23) {
+            totalHourWait = totalHourWait - 24*totalDayWait;
+        }
+        if(totalHourWait > 0){
+            time = totalHourWait+msgManager.getTimeHours()+" " + time;
+        }
+        if(totalDayWait > 0) {
+            time = totalDayWait+msgManager.getTimeDays()+" " + time;
+        }
+
+        if(time.endsWith(" ")) {
+            time = time.substring(0, time.length()-1);
+        }
+
+        return time;
+    }
+
+    public static Color getFireworkColorFromName(String colorName) {
+        try {
+            return (Color) Color.class.getDeclaredField(colorName).get(Color.class);
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static String replaceGlobalVariables(String text, Player player, PlayerKits2 plugin) {
+        if(player == null){
+            return text;
+        }
+        text = text.replace("%player%",player.getName());
+        if(plugin.getDependencyManager().isPlaceholderAPI()) {
+            text = PlaceholderAPI.setPlaceholders(player, text);
+        }
+
+        return text;
+    }
+
+    public static void addRangeToList(int min,int max, ArrayList<Integer> list){
+        for(int i=min;i<=max;i++){
+            list.add(i);
+        }
+    }
+}

src/main/java/pk/ajneb97/utils/PlayerUtils.java

@@ -0,0 +1,130 @@
+package pk.ajneb97.utils;
+
+import me.clip.placeholderapi.PlaceholderAPI;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+
+public class PlayerUtils {
+
+    public static ItemStack[] getAllInventoryContents(Player player){
+        if(Bukkit.getVersion().contains("1.8")) {
+            ItemStack[] contents = new ItemStack[40];
+
+            int slot = 0;
+            ItemStack[] normalContents = player.getInventory().getContents();
+            for(ItemStack item : normalContents){
+                contents[slot] = item;
+                slot++;
+            }
+            ItemStack[] armorContents = player.getInventory().getArmorContents();
+            for(ItemStack item : armorContents){
+                contents[slot] = item;
+                slot++;
+            }
+            return contents;
+        }else {
+            return player.getInventory().getContents();
+        }
+    }
+
+    public static int getUsedSlots(Player player){
+        ItemStack[] contents = getAllInventoryContents(player);
+        int usedSlots = 0;
+        for(int i=0;i<contents.length;i++) {
+            if(contents[i] != null && !contents[i].getType().equals(Material.AIR)) {
+                usedSlots++;
+            }
+        }
+
+        return usedSlots;
+    }
+
+    public static boolean isPlayerKitsAdmin(CommandSender sender){
+        return sender.hasPermission("playerkits.admin");
+    }
+
+    public static boolean hasCooldownBypassPermission(CommandSender sender){
+        return sender.hasPermission("playerkits.bypass.cooldown");
+    }
+
+    public static boolean hasOneTimeBypassPermission(CommandSender sender){
+        return sender.hasPermission("playerkits.bypass.onetime");
+    }
+
+    public static boolean passCondition(Player player,String condition) {
+        String[] sep = condition.split(" ");
+        String variable = sep[0];
+        variable = PlaceholderAPI.setPlaceholders(player, variable);
+        String conditional = sep[1];
+
+        if(conditional.equals(">=")) {
+            String[] conditionMiniSep = condition.split(" >= ");
+            String value = conditionMiniSep[1];
+            try {
+                double valueFinal = Double.valueOf(value);
+                double valueFinalVariable = Double.valueOf(variable);
+                if(valueFinalVariable >= valueFinal) {
+                    return true;
+                }
+            }catch(NumberFormatException e) {
+                return true;
+            }
+        }else if(conditional.equals("<=")) {
+            String[] conditionMiniSep = condition.split(" <= ");
+            String value = conditionMiniSep[1];
+            try {
+                double valueFinal = Double.valueOf(value);
+                double valueFinalVariable = Double.valueOf(variable);
+                if(valueFinalVariable <= valueFinal) {
+                    return true;
+                }
+            }catch(NumberFormatException e) {
+                return true;
+            }
+        }else if(conditional.equals("==")) {
+            String[] conditionMiniSep = condition.split(" == ");
+            String value = conditionMiniSep[1];
+            if(value.equals(variable)) {
+                return true;
+            }
+        }else if(conditional.equals("!=")) {
+            String[] conditionMiniSep = condition.split(" != ");
+            String value = conditionMiniSep[1];
+            if(!value.equals(variable)) {
+                return true;
+            }
+        }else if(conditional.equals(">")) {
+            String[] conditionMiniSep = condition.split(" > ");
+            String value = conditionMiniSep[1];
+            try {
+                double valueFinal = Double.valueOf(value);
+                double valueFinalVariable = Double.valueOf(variable);
+                if(valueFinalVariable > valueFinal) {
+                    return true;
+                }
+            }catch(NumberFormatException e) {
+                return true;
+            }
+        }else if(conditional.equals("<")) {
+            String[] conditionMiniSep = condition.split(" < ");
+            String value = conditionMiniSep[1];
+            try {
+                double valueFinal = Double.valueOf(value);
+                double valueFinalVariable = Double.valueOf(variable);
+                if(valueFinalVariable < valueFinal) {
+                    return true;
+                }
+            }catch(NumberFormatException e) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+}

src/main/java/pk/ajneb97/versions/NMSManager.java

@@ -0,0 +1,342 @@
+package pk.ajneb97.versions;
+
+import org.bukkit.Bukkit;
+import org.bukkit.inventory.ItemStack;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+public class NMSManager {
+
+    private ServerVersion serverVersion;
+    private Version version;
+
+    public NMSManager(){
+        this.version = new Version();
+        String packageName = Bukkit.getServer().getClass().getPackage().getName();
+        serverVersion = ServerVersion.valueOf(packageName.replace("org.bukkit.craftbukkit.", ""));
+
+        try {
+            //Classes
+            version.addClass("CraftItemStack",Class.forName("org.bukkit.craftbukkit."+serverVersion+".inventory.CraftItemStack"));
+            if(!serverVersionGreaterEqualThan(ServerVersion.v1_13_R1)) {
+                //Lower than 1.13
+                version.addClass("NBTTagList",Class.forName("net.minecraft.server."+serverVersion+".NBTTagList"));
+            }
+            if(serverVersionGreaterEqualThan(ServerVersion.v1_17_R1)){
+                version.addClass("ItemStackNMS",Class.forName("net.minecraft.world.item.ItemStack"));
+                version.addClass("NBTTagCompound",Class.forName("net.minecraft.nbt.NBTTagCompound"));
+                version.addClass("MojangsonParser",Class.forName("net.minecraft.nbt.MojangsonParser"));
+                version.addClass("NBTBase",Class.forName("net.minecraft.nbt.NBTBase"));
+            }else{
+                version.addClass("ItemStackNMS",Class.forName("net.minecraft.server."+serverVersion+".ItemStack"));
+                version.addClass("NBTTagCompound",Class.forName("net.minecraft.server."+serverVersion+".NBTTagCompound"));
+                version.addClass("MojangsonParser",Class.forName("net.minecraft.server."+serverVersion+".MojangsonParser"));
+                version.addClass("NBTBase",Class.forName("net.minecraft.server."+serverVersion+".NBTBase"));
+            }
+
+            //Methods
+            version.addMethod("asNMSCopy",version.getClassRef("CraftItemStack").getMethod("asNMSCopy",ItemStack.class));
+            version.addMethod("asBukkitCopy",version.getClassRef("CraftItemStack").getMethod("asBukkitCopy",version.getClassRef("ItemStackNMS")));
+            if(!serverVersionGreaterEqualThan(ServerVersion.v1_13_R1)){
+                //Lower than 1.13
+                version.addMethod("getList",version.getClassRef("NBTTagCompound").getMethod("getList",String.class,int.class));
+                version.addMethod("listSize",version.getClassRef("NBTTagList").getMethod("size"));
+                version.addMethod("listGet",version.getClassRef("NBTTagList").getMethod("get",int.class));
+                version.addMethod("listAdd",version.getClassRef("NBTTagList").getMethod("add",version.getClassRef("NBTBase")));
+            }
+            if(!serverVersionGreaterEqualThan(ServerVersion.v1_18_R1)){
+                version.addMethod("hasTag",version.getClassRef("ItemStackNMS").getMethod("hasTag"));
+                version.addMethod("getTag",version.getClassRef("ItemStackNMS").getMethod("getTag"));
+                version.addMethod("setTag",version.getClassRef("ItemStackNMS").getMethod("setTag",version.getClassRef("NBTTagCompound")));
+                version.addMethod("setString",version.getClassRef("NBTTagCompound").getMethod("setString",String.class,String.class));
+                version.addMethod("setBoolean",version.getClassRef("NBTTagCompound").getMethod("setBoolean",String.class,boolean.class));
+                version.addMethod("setDouble",version.getClassRef("NBTTagCompound").getMethod("setDouble",String.class,double.class));
+                version.addMethod("setInt",version.getClassRef("NBTTagCompound").getMethod("setInt",String.class,int.class));
+                version.addMethod("set",version.getClassRef("NBTTagCompound").getMethod("set",String.class,version.getClassRef("NBTBase")));
+                version.addMethod("hasKey",version.getClassRef("NBTTagCompound").getMethod("hasKey",String.class));
+                version.addMethod("getString",version.getClassRef("NBTTagCompound").getMethod("getString",String.class));
+                version.addMethod("getBoolean",version.getClassRef("NBTTagCompound").getMethod("getBoolean",String.class));
+                version.addMethod("getInt",version.getClassRef("NBTTagCompound").getMethod("getInt",String.class));
+                version.addMethod("getDouble",version.getClassRef("NBTTagCompound").getMethod("getDouble",String.class));
+                version.addMethod("getCompound",version.getClassRef("NBTTagCompound").getMethod("getCompound",String.class));
+                version.addMethod("get",version.getClassRef("NBTTagCompound").getMethod("get",String.class));
+                version.addMethod("remove",version.getClassRef("NBTTagCompound").getMethod("remove",String.class));
+                if(serverVersionGreaterEqualThan(ServerVersion.v1_13_R1)){
+                    version.addMethod("getKeys",version.getClassRef("NBTTagCompound").getMethod("getKeys"));
+                }else{
+                    version.addMethod("getKeys",version.getClassRef("NBTTagCompound").getMethod("c"));
+                }
+                version.addMethod("hasKeyOfType",version.getClassRef("NBTTagCompound").getMethod("hasKeyOfType",String.class,int.class));
+                version.addMethod("parse",version.getClassRef("MojangsonParser").getMethod("parse",String.class));
+            }else{
+                String methodName = null;
+                switch(serverVersion){
+                    case v1_18_R1: methodName = "r"; break;
+                    case v1_18_R2: methodName = "s"; break;
+                    case v1_19_R1:
+                    case v1_19_R2:
+                    case v1_19_R3: methodName = "t"; break;
+                    case v1_20_R1: methodName = "u"; break;
+                }
+                version.addMethod("hasTag",version.getClassRef("ItemStackNMS").getMethod(methodName));
+
+                methodName = null;
+                switch(serverVersion){
+                    case v1_18_R1: methodName = "s"; break;
+                    case v1_18_R2: methodName = "t"; break;
+                    case v1_19_R1:
+                    case v1_19_R2:
+                    case v1_19_R3: methodName = "u"; break;
+                    case v1_20_R1: methodName = "v"; break;
+                }
+                version.addMethod("getTag",version.getClassRef("ItemStackNMS").getMethod(methodName));
+
+                version.addMethod("setTag",version.getClassRef("ItemStackNMS").getMethod("c",version.getClassRef("NBTTagCompound")));
+                version.addMethod("setString",version.getClassRef("NBTTagCompound").getMethod("a",String.class,String.class));
+                version.addMethod("setBoolean",version.getClassRef("NBTTagCompound").getMethod("a",String.class,boolean.class));
+                version.addMethod("setDouble",version.getClassRef("NBTTagCompound").getMethod("a",String.class,double.class));
+                version.addMethod("setInt",version.getClassRef("NBTTagCompound").getMethod("a",String.class,int.class));
+                version.addMethod("set",version.getClassRef("NBTTagCompound").getMethod("a",String.class,version.getClassRef("NBTBase")));
+                version.addMethod("hasKey",version.getClassRef("NBTTagCompound").getMethod("e",String.class));
+                version.addMethod("getString",version.getClassRef("NBTTagCompound").getMethod("l",String.class));
+                version.addMethod("getBoolean",version.getClassRef("NBTTagCompound").getMethod("q",String.class));
+                version.addMethod("getInt",version.getClassRef("NBTTagCompound").getMethod("h",String.class));
+                version.addMethod("getDouble",version.getClassRef("NBTTagCompound").getMethod("k",String.class));
+                version.addMethod("getCompound",version.getClassRef("NBTTagCompound").getMethod("p",String.class));
+                version.addMethod("get",version.getClassRef("NBTTagCompound").getMethod("c",String.class));
+                version.addMethod("remove",version.getClassRef("NBTTagCompound").getMethod("r",String.class));
+
+                methodName = null;
+                switch(serverVersion){
+                    case v1_18_R1:
+                    case v1_18_R2:
+                    case v1_19_R1: methodName = "d"; break;
+                    case v1_19_R2:
+                    case v1_19_R3:
+                    case v1_20_R1: methodName = "e"; break;
+                }
+                version.addMethod("getKeys",version.getClassRef("NBTTagCompound").getMethod(methodName));
+                version.addMethod("hasKeyOfType",version.getClassRef("NBTTagCompound").getMethod("b",String.class,int.class));
+                version.addMethod("parse",version.getClassRef("MojangsonParser").getMethod("a",String.class));
+            }
+
+
+
+
+
+        } catch (ClassNotFoundException | NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public ItemStack setTagStringItem(ItemStack item, String key, String value) {
+        try {
+            Object newItem = version.getMethodRef("asNMSCopy").invoke(null,item); //ItemStackNMS
+            Object compound = getNBTCompound(newItem);
+            version.getMethodRef("setString").invoke(compound,key,value);
+            version.getMethodRef("setTag").invoke(newItem,compound);
+            return (ItemStack)version.getMethodRef("asBukkitCopy").invoke(null,newItem);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            e.printStackTrace();
+        }
+        return item;
+    }
+
+    public String getTagStringItem(ItemStack item,String key) {
+        try {
+            Object newItem = version.getMethodRef("asNMSCopy").invoke(null,item); //ItemStackNMS
+            Object compound = getNBTCompound(newItem);
+            if((boolean)version.getMethodRef("hasKey").invoke(compound,key)){
+                return (String)version.getMethodRef("getString").invoke(compound,key);
+            }
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public ItemStack removeTagItem(ItemStack item, String key) {
+        try {
+            Object newItem = version.getMethodRef("asNMSCopy").invoke(null,item); //ItemStackNMS
+            Object compound = getNBTCompound(newItem);
+            version.getMethodRef("remove").invoke(compound,key);
+            version.getMethodRef("setTag").invoke(newItem,compound);
+            return (ItemStack)version.getMethodRef("asBukkitCopy").invoke(null,newItem);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            e.printStackTrace();
+        }
+        return item;
+    }
+
+    public List<String> getNBT(ItemStack item){
+        List<String> nbtList = new ArrayList<>();
+        try {
+            Object newItem = version.getMethodRef("asNMSCopy").invoke(null,item); //ItemStackNMS
+            if((boolean)version.getMethodRef("hasTag").invoke(newItem,null)){
+                Object compound = version.getMethodRef("getTag").invoke(newItem,null);
+                Set<String> tags = (Set<String>) version.getMethodRef("getKeys").invoke(compound,null);
+                for(String t : tags) {
+                    if(!t.equals("ench") && !t.equals("HideFlags") && !t.equals("display")
+                            && !t.equals("SkullOwner") && !t.equals("AttributeModifiers")
+                            && !t.equals("Enchantments") && !t.equals("Damage") && !t.equals("CustomModelData") && !t.equals("Potion")
+                            && !t.equals("StoredEnchantments") && !t.equals("CustomPotionColor") && !t.equals("CustomPotionEffects") && !t.equals("Fireworks")
+                            && !t.equals("Explosion")&& !t.equals("pages") && !t.equals("title") && !t.equals("author") && !t.equals("resolved")
+                            && !t.equals("generation") && !t.equals("Trim")) {
+                        if((boolean)version.getMethodRef("hasKeyOfType").invoke(compound,t,1)) {
+                            //boolean
+                            nbtList.add(t+"|"+version.getMethodRef("getBoolean").invoke(compound,t)+"|boolean");
+                        }else if((boolean)version.getMethodRef("hasKeyOfType").invoke(compound,t,3)) {
+                            //int
+                            nbtList.add(t+"|"+version.getMethodRef("getInt").invoke(compound,t)+"|int");
+                        }else if((boolean)version.getMethodRef("hasKeyOfType").invoke(compound,t,6)) {
+                            //double
+                            nbtList.add(t+"|"+version.getMethodRef("getDouble").invoke(compound,t)+"|double");
+                        }else if((boolean)version.getMethodRef("hasKeyOfType").invoke(compound,t,10)){
+                            //Compound
+                            nbtList.add(t+"|"+version.getMethodRef("getCompound").invoke(compound,t)+"|compound");
+                        }else if((boolean)version.getMethodRef("hasKeyOfType").invoke(compound,t,8)) {
+                            //String
+                            nbtList.add(t+"|"+version.getMethodRef("getString").invoke(compound,t));
+                        }else {
+                            //Other
+                            nbtList.add(t+"|"+version.getMethodRef("get").invoke(compound,t));
+                        }
+                    }
+                }
+            }
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            e.printStackTrace();
+        }
+        return nbtList;
+    }
+
+    public ItemStack setNBT(ItemStack item, List<String> nbtList) {
+        if(nbtList == null || nbtList.isEmpty()) {
+            return item;
+        }
+
+        try {
+            Object newItem = version.getMethodRef("asNMSCopy").invoke(null,item); //ItemStackNMS
+            Object compound = getNBTCompound(newItem);
+            for(int i=0;i<nbtList.size();i++) {
+                String nbt = nbtList.get(i);
+                String[] sep = nbtList.get(i).split("\\|");
+                String id = sep[0];
+                String type = sep[sep.length-1];
+
+                if(type.equals("boolean")) {
+                    version.getMethodRef("setBoolean").invoke(compound,sep[0],Boolean.parseBoolean(sep[1]));
+                }else if(type.equals("double")) {
+                    version.getMethodRef("setDouble").invoke(compound,sep[0],Double.parseDouble(sep[1]));
+                }else if(type.equals("int")) {
+                    version.getMethodRef("setInt").invoke(compound,sep[0],Integer.parseInt(sep[1]));
+                }else if(type.equals("compound")) {
+                    String finalNBT = nbt.replace(id+"|", "").replace("|compound", "");
+                    Object compoundNew = version.getMethodRef("parse").invoke(null,finalNBT);
+                    version.getMethodRef("set").invoke(compound,sep[0],compoundNew);
+                }else {
+                    version.getMethodRef("setString").invoke(compound,sep[0],nbt.replace(id+"|", ""));
+                }
+
+            }
+            version.getMethodRef("setTag").invoke(newItem,compound);
+            return (ItemStack)version.getMethodRef("asBukkitCopy").invoke(null,newItem);
+        }catch(IllegalAccessException | IllegalArgumentException | InvocationTargetException | SecurityException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public List<String> getAttributes(ItemStack item) {
+        try {
+            Object newItem = version.getMethodRef("asNMSCopy").invoke(null,item); //ItemStackNMS
+            if((boolean)version.getMethodRef("hasTag").invoke(newItem,null)) {
+                Object compound = version.getMethodRef("getTag").invoke(newItem, null);
+                if((boolean)version.getMethodRef("hasKey").invoke(compound,"AttributeModifiers")){
+                    List<String> attributeList = new ArrayList<>();
+                    Object attributes = version.getMethodRef("getList").invoke(compound,"AttributeModifiers",10); //NBTTagList
+                    for(int i=0;i<(int)version.getMethodRef("listSize").invoke(attributes);i++){
+                        Object compoundI = version.getMethodRef("listGet").invoke(attributes,i);
+                        String attributeName = (String)version.getMethodRef("getString").invoke(compoundI,"AttributeName");
+                        String name = (String)version.getMethodRef("getString").invoke(compoundI,"Name");
+                        double amount = (double)version.getMethodRef("getDouble").invoke(compoundI,"Amount");
+                        int operation = (int)version.getMethodRef("getInt").invoke(compoundI,"Operation");
+                        int uuidLeast = (int)version.getMethodRef("getInt").invoke(compoundI,"UUIDLeast");
+                        int uuidMost = (int)version.getMethodRef("getInt").invoke(compoundI,"UUIDMost");
+                        String all = attributeName+";"+name+";"+amount+";"+operation+";"+uuidLeast+";"+uuidMost;
+                        if((boolean)version.getMethodRef("hasKey").invoke(compoundI,"Slot")) {
+                            all = all+";"+version.getMethodRef("getString").invoke(compoundI,"Slot");
+                        }
+
+                        attributeList.add(all);
+                    }
+
+                    return attributeList;
+                }
+            }
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public ItemStack setAttributes(ItemStack item, List<String> attributeList) {
+        try{
+            Object newItem = version.getMethodRef("asNMSCopy").invoke(null,item); //ItemStackNMS
+            Object compound = getNBTCompound(newItem);
+            Object attributesList = version.getClassRef("NBTTagList").newInstance();
+            for(int i=0;i<attributeList.size();i++){
+                Object attributeCompound = version.getClassRef("NBTTagCompound").newInstance();
+
+                String[] data = attributeList.get(i).split(";");
+                String attributeName = data[0];
+                String name = data[1];
+                double amount = Double.valueOf(data[2]);
+                int operation = Integer.valueOf(data[3]);
+                int uuidLeast = Integer.valueOf(data[4]);
+                int uuidMost = Integer.valueOf(data[5]);
+
+                version.getMethodRef("setString").invoke(attributeCompound,"AttributeName",attributeName);
+                version.getMethodRef("setString").invoke(attributeCompound,"Name",name);
+                version.getMethodRef("setDouble").invoke(attributeCompound,"Amount",amount);
+                version.getMethodRef("setInt").invoke(attributeCompound,"Operation",operation);
+                version.getMethodRef("setInt").invoke(attributeCompound,"UUIDLeast",uuidLeast);
+                version.getMethodRef("setInt").invoke(attributeCompound,"UUIDMost",uuidMost);
+                if(data.length >= 7) {
+                    String slot = data[6];
+                    version.getMethodRef("setString").invoke(attributeCompound,"Slot",slot);
+                }
+                version.getMethodRef("listAdd").invoke(attributesList,attributeCompound);
+            }
+
+            version.getMethodRef("set").invoke(compound,"AttributeModifiers",attributesList);
+            version.getMethodRef("setTag").invoke(newItem,compound);
+
+            return (ItemStack)version.getMethodRef("asBukkitCopy").invoke(null,newItem);
+        } catch (IllegalAccessException | InvocationTargetException | InstantiationException e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    private Object getNBTCompound(Object newItem){
+        try {
+            boolean hasTag = (boolean)version.getMethodRef("hasTag").invoke(newItem,null);
+            Object compound = hasTag ? version.getMethodRef("getTag").invoke(newItem,null) :
+                    version.getClassRef("NBTTagCompound").newInstance();
+            return compound;
+        } catch (IllegalAccessException | InvocationTargetException | InstantiationException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+
+
+    private boolean serverVersionGreaterEqualThan(ServerVersion version){
+        return serverVersion.ordinal() > version.ordinal();
+    }
+}

src/main/java/pk/ajneb97/versions/ServerVersion.java

@@ -0,0 +1,26 @@
+package pk.ajneb97.versions;
+
+public enum ServerVersion {
+    v1_8_R1,
+    v1_8_R2,
+    v1_8_R3,
+    v1_9_R1,
+    v1_9_R2,
+    v1_10_R1,
+    v1_11_R1,
+    v1_12_R1,
+    v1_13_R1,
+    v1_13_R2,
+    v1_14_R1,
+    v1_15_R1,
+    v1_16_R1,
+    v1_16_R2,
+    v1_16_R3,
+    v1_17_R1,
+    v1_18_R1,
+    v1_18_R2,
+    v1_19_R1,
+    v1_19_R2,
+    v1_19_R3,
+    v1_20_R1,
+}

src/main/java/pk/ajneb97/versions/Version.java

@@ -0,0 +1,30 @@
+package pk.ajneb97.versions;
+
+import java.lang.reflect.Method;
+import java.util.HashMap;
+
+public class Version {
+    private HashMap<String,Class<?>> classes;
+    private HashMap<String, Method> methods;
+
+    public Version(){
+        this.classes = new HashMap<>();
+        this.methods = new HashMap<>();
+    }
+
+    public void addClass(String name,Class<?> classType){
+        classes.put(name,classType);
+    }
+
+    public void addMethod(String name,Method methodType){
+        methods.put(name,methodType);
+    }
+
+    public Class<?> getClassRef(String name){
+        return classes.get(name);
+    }
+
+    public Method getMethodRef(String name){
+        return methods.get(name);
+    }
+}

src/main/resources/config.yml

@@ -0,0 +1,49 @@
+drop_items_if_full_inventory: false
+claim_kit_short_command: false
+close_inventory_on_claim: false
+kit_preview: true
+kit_preview_requires_kit_permission: false
+first_join_kit: none
+new_kit_default_inventory: "main_inventory"
+new_kit_default_values:
+  cooldown: 3600
+  permission_required: false
+  actions:
+    claim:
+      1:
+        action: "playsound: BLOCK_NOTE_BLOCK_PLING;10;2"
+    error:
+      1:
+        action: "playsound: BLOCK_NOTE_BLOCK_PLING;10;0.1"
+  display:
+    default:
+      id: STONE_SWORD
+      name: "&c&l%kit_name% &cKit"
+      lore:
+        - '&fThis is a description of the kit.'
+        - ''
+        - '&7Edit it on the &c%kit_name%.yml &7file'
+        - '&7or using &c/kit edit %kit_name%'
+      item_flags:
+        - HIDE_ATTRIBUTES
+    no_permission:
+      id: BARRIER
+      name: "&c&l%kit_name% &cKit"
+      lore:
+        - "&cYou don't have permissions to claim"
+        - "&cthis kit."
+    cooldown:
+      id: STONE_SWORD
+      name: "&c&l%kit_name% &cKit"
+      lore:
+        - "&cYou need to wait &7%time%"
+        - "&cto claim this kit again."
+player_data_save_time: 300
+update_notify: true
+mysql_database:
+  enabled: false
+  host: localhost
+  port: 3306
+  username: root
+  password: root
+  database: database

src/main/resources/inventory.yml

@@ -0,0 +1,60 @@
+inventories:
+  main_inventory:
+    slots: 54
+    title: "&4&lKits"
+    0;1;7;8;9;17;36;44;45;46;52;53:
+      item:
+        id: "BLACK_STAINED_GLASS_PANE"
+        name: " "
+    20:
+      type: "kit: iron"
+    24:
+      type: "kit: food"
+    49:
+      item:
+        id: "DIAMOND_BLOCK"
+        name: "&ePremium Kits"
+      open_inventory: premium_kits_inventory
+  premium_kits_inventory:
+    slots: 54
+    title: "&e&lPremium Kits"
+    0;1;7;8;9;17;36;44;45;46;52;53:
+      item:
+        id: "YELLOW_STAINED_GLASS_PANE"
+        name: " "
+    22:
+      type: "kit: diamond"
+    49:
+      item:
+        id: "IRON_BLOCK"
+        name: "&eNormal Kits"
+      open_inventory: main_inventory
+  preview_inventory:
+    slots: 54
+    title: "&4&lKit Preview"
+    45:
+      item:
+        id: "ARROW"
+        name: "&7Go Back"
+      open_inventory: previous
+  buy_requirements_inventory:
+    slots: 27
+    title: "&4&lBuy Kit Requirements"
+    13:
+      item:
+        id: "BOOK"
+        name: "&c&lRequirements"
+        lore:
+          - "%kit_requirements_message%"
+    10:
+      item:
+        id: "RED_STAINED_GLASS_PANE"
+        name: "&cGo Back"
+        nbt:
+          - "playerkits_buy|no"
+    16:
+      item:
+        id: "GREEN_STAINED_GLASS_PANE"
+        name: "&aBuy"
+        nbt:
+          - "playerkits_buy|yes"

src/main/resources/kits/diamond.yml

@@ -0,0 +1,91 @@
+cooldown: 43200
+permission_required: true
+items:
+  1:
+    id: DIAMOND_AXE
+    amount: 1
+  2:
+    id: DIAMOND_PICKAXE
+    amount: 1
+  3:
+    id: DIAMOND_SWORD
+    name: "&4Super Sword"
+    amount: 1
+    lore:
+      - "&7Best sword on the server."
+      - ""
+      - "&7Owner: &6%player_name%"
+    enchants:
+      - "DAMAGE_ALL;5"
+actions:
+  claim:
+    1:
+      action: "console_command: bc &6%player% &ejust claimed a &aDIAMOND KIT&e!"
+      display_item:
+        id: "BOOK"
+        name: "&4Announcement"
+        lore:
+          - "&7Claiming this kit will send an announcement"
+          - "&7to the whole server."
+    2:
+      action: "playsound: BLOCK_NOTE_BLOCK_PLING;10;2"
+  error:
+    1:
+      action: "playsound: BLOCK_NOTE_BLOCK_PLING;10;0.1"
+requirements:
+  one_time_requirements: false
+  price: 5000
+  message:
+  - '&fYou need $5000'
+  - '&8Status: &7$%vault_eco_balance% %status_symbol_price%'
+  - ''
+  - '&fYou need level 20+'
+  - '&8Status: &7$%player_level% %status_symbol_requirement_1%'
+  extra_requirements:
+  - "%player_level% >= 20"
+display:
+  default:
+    id: DIAMOND_SWORD
+    name: '&c&lDiamond &cKit'
+    amount: 1
+    lore:
+      - '&fThis kit includes:'
+      - '&8- &7x1 Diamond Axe'
+      - '&8- &7x1 Diamond Pickaxe'
+      - '&8- &7x1 Diamond Sword'
+      - ''
+      - '&7Cooldown: &c12 hours'
+      - '&7Price: &a$5000'
+      - ''
+      - '&aLeft Click to buy!'
+      - '&bRight Click to preview!'
+    item_flags:
+      - HIDE_ATTRIBUTES
+  no_permission:
+    id: BARRIER
+    name: '&c&lDiamond &cKit'
+    amount: 1
+    lore:
+      - '&fThis kit includes:'
+      - '&8- &7x1 Diamond Axe'
+      - '&8- &7x1 Diamond Pickaxe'
+      - '&8- &7x1 Diamond Sword'
+      - ''
+      - '&cYou don''t have permissions'
+      - '&cto claim this kit.'
+      - ''
+      - '&7You need: &bVIP&6+ &7rank.'
+  cooldown:
+    id: DIAMOND_SWORD
+    name: '&c&lDiamond &cKit'
+    amount: 1
+    lore:
+      - '&fThis kit includes:'
+      - '&8- &7x1 Diamond Axe'
+      - '&8- &7x1 Diamond Pickaxe'
+      - '&8- &7x1 Diamond Sword'
+      - ''
+      - '&cYou need to wait &7%time%'
+      - '&cto claim this kit again.'
+    item_flags:
+      - HIDE_ATTRIBUTES

src/main/resources/kits/food.yml

@@ -0,0 +1,38 @@
+cooldown: 3600
+items:
+  1:
+    id: COOKED_BEEF
+    amount: 5
+  2:
+    id: COOKED_CHICKEN
+    amount: 5
+display:
+  default:
+    id: COOKED_BEEF
+    name: '&c&lFood &cKit'
+    lore:
+      - '&fThis kit includes:'
+      - '&8- &7x5 Cooked Beef'
+      - '&8- &7x5 Cooked Chicken'
+      - ' '
+      - '&7Cooldown: &c1 hour'
+      - ''
+      - '&aLeft Click to claim!'
+      - '&bRight Click to preview!'
+  cooldown:
+    id: COOKED_BEEF
+    name: "&c&lFood &cKit"
+    lore:
+      - '&fThis kit includes:'
+      - '&8- &7x5 Cooked Beef'
+      - '&8- &7x5 Cooked Chicken'
+      - ' '
+      - "&cYou need to wait &7%time%"
+      - "&cto claim this kit again."
+actions:
+  claim:
+    1:
+      action: "playsound: BLOCK_NOTE_BLOCK_PLING;10;2"
+  error:
+    1:
+      action: "playsound: BLOCK_NOTE_BLOCK_PLING;10;0.1"

src/main/resources/kits/iron.yml

@@ -0,0 +1,47 @@
+cooldown: 10800
+items:
+  1:
+    id: IRON_AXE
+    amount: 1
+  2:
+    id: IRON_PICKAXE
+    amount: 1
+  3:
+    id: IRON_SWORD
+    amount: 1
+display:
+  default:
+    id: IRON_AXE
+    name: '&c&lIron &cKit'
+    lore:
+      - '&fThis kit includes:'
+      - '&8- &7x1 Iron Axe'
+      - '&8- &7x1 Iron Pickaxe'
+      - '&8- &7x1 Iron Sword'
+      - ' '
+      - '&7Cooldown: &c3 hours'
+      - ''
+      - '&aLeft Click to claim!'
+      - '&bRight Click to preview!'
+    item_flags:
+      - HIDE_ATTRIBUTES
+  cooldown:
+    id: IRON_AXE
+    name: "&c&lIron &cKit"
+    lore:
+      - '&fThis kit includes:'
+      - '&8- &7x1 Iron Axe'
+      - '&8- &7x1 Iron Pickaxe'
+      - '&8- &7x1 Iron Sword'
+      - ' '
+      - "&cYou need to wait &7%time%"
+      - "&cto claim this kit again."
+    item_flags:
+      - HIDE_ATTRIBUTES
+actions:
+  claim:
+    1:
+      action: "playsound: BLOCK_NOTE_BLOCK_PLING;10;2"
+  error:
+    1:
+      action: "playsound: BLOCK_NOTE_BLOCK_PLING;10;0.1"

src/main/resources/messages.yml

@@ -0,0 +1,38 @@
+prefix: "&8[&bPlayerKits&a²&8] "
+kitDoesNotExists: "&cThe kit &7%kit% &cdoesn't exists."
+kitNoPermissions: "&cYou don't have permissions to claim this kit."
+noSpaceError: "&cYou don't have enough space in your inventory."
+commandReload: "&aConfig Reloaded."
+commandGiveError: "&cYou need to use: &7/kit give <kit> <player>"
+commandGiveError2: "&cThere was an error giving the kit: &7%error%"
+commandGiveCorrect: "&aKit &7%kit% &agiven to &e%player%&a!"
+commandClaimError: "&cYou need to use: &7/kit claim <kit>"
+commandCreateError: "&cYou need to use: &7/kit create <name>"
+commandDeleteError: "&cYou need to use: &7/kit delete <name>"
+commandResetError: "&cYou need to use: &7/kit reset <kit> <player>"
+commandEditError: "&cYou need to use: &7/kit edit <kit>"
+commandDoesNotExists: "&cThat command doesn't exists."
+playerNotOnline: "&cPlayer &7%player% &cis not online."
+oneTimeError: "&cYou can't claim this kit again."
+cooldownError: "&cYou need to wait &7%time% &cto claim this kit again."
+kitReceived: "&aKit &7%kit% &areceived."
+kitAlreadyExists: "&cThe kit &7%kit% &calready exists on the config."
+inventoryEmpty: "&cYou need at least 1 item on your inventory to create a kit."
+kitCreated: "&aKit &7%kit% &acreated correctly."
+kitNotAddedToInventory: "&eIt was not possible to automatically add the kit to the inventory. There is no more space left."
+kitAddedToInventory: "&eKit item added to the &7%inventory% &edefault inventory on slot &7%slot%&e!"
+noPermissions: "&cYou don't have permissions for that."
+kitDeleted: "&aKit &7%kit% &adeleted correctly."
+playerDataNotFound: "&cNo data found for player &7%player%&c."
+kitResetCorrect: "&aKit &7%kit% &areset for &7%player%&a!"
+cantPreviewError: "&cYou can't preview this kit."
+requirementsMessageStatusSymbolTrue: "&a&l✔"
+requirementsMessageStatusSymbolFalse: "&c&l✖"
+requirementsError: "&cYou dont't have the necessary requirements to buy this!"
+seconds: 's'
+minutes: 'm'
+hours: 'h'
+days: 'd'
+cooldownPlaceholderReady: "&a&lReady!"
+
+

src/main/resources/plugin.yml

@@ -0,0 +1,11 @@
+main: pk.ajneb97.PlayerKits2
+version: 1.0.1
+name: PlayerKits2
+api-version: 1.13
+softdepend: [Vault,PlaceholderAPI]
+author: Ajneb97
+
+commands:
+  kit:
+    description: Main command of PlayerKits2
+    aliases: [kits,playerkits]