commit 073e1a8f27affe9f7c799f55415b31ed420bb513 Author: Ajneb97 Date: Tue Sep 12 15:22:21 2023 -0300 Initial commit diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..dfe0770 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +# Auto detect text files and perform LF normalization +* text=auto diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..085705a --- /dev/null +++ b/.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/ diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d369da0 --- /dev/null +++ b/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. diff --git a/README.md b/README.md new file mode 100644 index 0000000..52a56f2 --- /dev/null +++ b/README.md @@ -0,0 +1,2 @@ +# PlayerKits2 + diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..30f538e --- /dev/null +++ b/pom.xml @@ -0,0 +1,103 @@ + + + 4.0.0 + + pk.ajneb97 + PlayerKits2 + 1.0-SNAPSHOT + + + 8 + 8 + UTF-8 + + + + + spigot-repo + https://hub.spigotmc.org/nexus/content/repositories/snapshots/ + + + placeholderapi + https://repo.extendedclip.com/content/repositories/placeholderapi/ + + + jitpack.io + https://jitpack.io + + + minecraft-repo + https://libraries.minecraft.net/ + + + + + + org.spigotmc + spigot-api + 1.20.1-R0.1-SNAPSHOT + provided + + + me.clip + placeholderapi + 2.11.1 + provided + + + com.github.MilkBowl + VaultAPI + 1.7 + provided + + + com.mojang + authlib + 1.5.25 + provided + + + com.zaxxer + HikariCP + 4.0.3 + + + + + + + maven-compiler-plugin + 3.8.1 + + 1.8 + 1.8 + + + + org.apache.maven.plugins + maven-shade-plugin + 3.2.4 + + + + + package + + shade + + + + + com.zaxxer.HikariCP + pk.ajneb97.libs.hikaricp + + + + + + + + + \ No newline at end of file diff --git a/src/main/java/pk/ajneb97/MainCommand.java b/src/main/java/pk/ajneb97/MainCommand.java new file mode 100644 index 0000000..bf6941e --- /dev/null +++ b/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 (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 &8Claims a kit outside the GUI.")); + sender.sendMessage(MessagesManager.getColoredMessage("&6/kit create &8Creates a new kit using the items in your inventory.")); + sender.sendMessage(MessagesManager.getColoredMessage("&6/kit edit &8Edits a kit.")); + sender.sendMessage(MessagesManager.getColoredMessage("&6/kit give &8Gives a kit to a player.")); + sender.sendMessage(MessagesManager.getColoredMessage("&6/kit delete &8Deletes a kit.")); + sender.sendMessage(MessagesManager.getColoredMessage("&6/kit reset &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 + 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 + 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 + 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 + 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 + 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 + 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 + 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 onTabComplete(CommandSender sender, Command command, String label, String[] args) { + FileConfiguration configFile = plugin.getConfigsManager().getMainConfigManager().getConfig(); + boolean claimKitShortCommand = configFile.getBoolean("claim_kit_short_command"); + + List completions = new ArrayList(); + List commands = new ArrayList(); + + if(args.length == 1) { + if(claimKitShortCommand){ + List 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 getKitCompletions(CommandSender sender,String[] args,int argKitPos){ + List completions = new ArrayList<>(); + String argKit = args[argKitPos]; + + ArrayList 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; + } +} diff --git a/src/main/java/pk/ajneb97/PlayerKits2.java b/src/main/java/pk/ajneb97/PlayerKits2.java new file mode 100644 index 0000000..3bbd161 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/pk/ajneb97/api/ExpansionPlayerKits.java b/src/main/java/pk/ajneb97/api/ExpansionPlayerKits.java new file mode 100644 index 0000000..2c9a0e3 --- /dev/null +++ b/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_% + String event = identifier.replace("cooldown_", ""); + return PlayerKitsAPI.getKitCooldown(player,event); + }else if(identifier.startsWith("onetime_ready_")){ + // %conditionalevents_onetime_ready_% + String event = identifier.replace("onetime_ready_", ""); + return PlayerKitsAPI.getOneTimeReady(player,event); + } + + return null; + } +} diff --git a/src/main/java/pk/ajneb97/api/PlayerKitsAPI.java b/src/main/java/pk/ajneb97/api/PlayerKitsAPI.java new file mode 100644 index 0000000..0423ef9 --- /dev/null +++ b/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"; + } + } +} diff --git a/src/main/java/pk/ajneb97/configs/ConfigsManager.java b/src/main/java/pk/ajneb97/configs/ConfigsManager.java new file mode 100644 index 0000000..af3a89b --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/pk/ajneb97/configs/CustomConfig.java b/src/main/java/pk/ajneb97/configs/CustomConfig.java new file mode 100644 index 0000000..e8aa1f3 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/pk/ajneb97/configs/InventoryConfigManager.java b/src/main/java/pk/ajneb97/configs/InventoryConfigManager.java new file mode 100644 index 0000000..6d4a6b9 --- /dev/null +++ b/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 inventories = new ArrayList(); + 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 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 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 commands = new ArrayList<>(); + getConfig().set("Config.register_commands", commands); + saveConfig(); + } + */ + }catch(IOException e){ + e.printStackTrace(); + } + } + +} diff --git a/src/main/java/pk/ajneb97/configs/KitsConfigManager.java b/src/main/java/pk/ajneb97/configs/KitsConfigManager.java new file mode 100644 index 0000000..a0080b0 --- /dev/null +++ b/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 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 getConfigs(){ + return this.configFiles; + } + + public boolean fileAlreadyRegistered(String pathName) { + for(int i=0;i kits = new ArrayList(); + 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 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 items = new ArrayList(); + 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 claimActions = getActions(config,"claim",mainPath,kitItemManager); + ArrayList 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 extraRequirements = config.getStringList("requirements.extra_requirements"); + List message = config.getStringList("requirements.message"); + List 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 getActions(FileConfiguration config,String actionType,String mainPath,KitItemManager kitItemManager){ + ArrayList 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; + } +} diff --git a/src/main/java/pk/ajneb97/configs/MainConfigManager.java b/src/main/java/pk/ajneb97/configs/MainConfigManager.java new file mode 100644 index 0000000..ca19121 --- /dev/null +++ b/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 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; + } +} diff --git a/src/main/java/pk/ajneb97/configs/MessagesConfigManager.java b/src/main/java/pk/ajneb97/configs/MessagesConfigManager.java new file mode 100644 index 0000000..ed4a826 --- /dev/null +++ b/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 commands = new ArrayList<>(); + getConfig().set("Config.register_commands", commands); + saveConfig(); + } + */ + }catch(IOException e){ + e.printStackTrace(); + } + } +} diff --git a/src/main/java/pk/ajneb97/configs/PlayersConfigManager.java b/src/main/java/pk/ajneb97/configs/PlayersConfigManager.java new file mode 100644 index 0000000..b45c42a --- /dev/null +++ b/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 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 getConfigs(){ + return this.configFiles; + } + + public boolean fileAlreadyRegistered(String pathName) { + for(int i=0;i players = new ArrayList<>(); + + for(CustomConfig configFile : configFiles) { + FileConfiguration config = configFile.getConfig(); + + String uuid = configFile.getPath().replace(".yml", ""); + String name = config.getString("name"); + ArrayList 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 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(); + } + +} diff --git a/src/main/java/pk/ajneb97/database/HikariConnection.java b/src/main/java/pk/ajneb97/database/HikariConnection.java new file mode 100644 index 0000000..4c9fcac --- /dev/null +++ b/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(); + } + } +} diff --git a/src/main/java/pk/ajneb97/database/MySQLConnection.java b/src/main/java/pk/ajneb97/database/MySQLConnection.java new file mode 100644 index 0000000..b32e2d3 --- /dev/null +++ b/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 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 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); + } +} diff --git a/src/main/java/pk/ajneb97/database/PlayerCallback.java b/src/main/java/pk/ajneb97/database/PlayerCallback.java new file mode 100644 index 0000000..2008151 --- /dev/null +++ b/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); +} diff --git a/src/main/java/pk/ajneb97/libs/actionbar/ActionBarAPI.java b/src/main/java/pk/ajneb97/libs/actionbar/ActionBarAPI.java new file mode 100644 index 0000000..850e10b --- /dev/null +++ b/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); + } + } + +} diff --git a/src/main/java/pk/ajneb97/libs/titles/TitleAPI.java b/src/main/java/pk/ajneb97/libs/titles/TitleAPI.java new file mode 100644 index 0000000..30b90ce --- /dev/null +++ b/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(); + } + } +} \ No newline at end of file diff --git a/src/main/java/pk/ajneb97/listeners/InventoryEditListener.java b/src/main/java/pk/ajneb97/listeners/InventoryEditListener.java new file mode 100644 index 0000000..7a83483 --- /dev/null +++ b/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); + } + } +} diff --git a/src/main/java/pk/ajneb97/listeners/PlayerListener.java b/src/main/java/pk/ajneb97/listeners/PlayerListener.java new file mode 100644 index 0000000..35d06de --- /dev/null +++ b/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); + } + } + } +} diff --git a/src/main/java/pk/ajneb97/managers/DependencyManager.java b/src/main/java/pk/ajneb97/managers/DependencyManager.java new file mode 100644 index 0000000..1b0a1cd --- /dev/null +++ b/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 rsp = Bukkit.getServer().getServicesManager().getRegistration(Economy.class); + if(rsp != null){ + vaultEconomy = rsp.getProvider(); + } + } + } + + public boolean isPlaceholderAPI() { + return isPlaceholderAPI; + } + + public Economy getVaultEconomy() { + return vaultEconomy; + } +} diff --git a/src/main/java/pk/ajneb97/managers/InventoryManager.java b/src/main/java/pk/ajneb97/managers/InventoryManager.java new file mode 100644 index 0000000..e9fb0fb --- /dev/null +++ b/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 inventories; + private ArrayList players; + private InventoryRequirementsManager inventoryRequirementsManager; + public InventoryManager(PlayerKits2 plugin){ + this.plugin = plugin; + this.players = new ArrayList<>(); + this.inventoryRequirementsManager = new InventoryRequirementsManager(plugin,this); + } + + public ArrayList getPlayers() { + return players; + } + + public ArrayList getInventories() { + return inventories; + } + + public InventoryRequirementsManager getInventoryRequirementsManager() { + return inventoryRequirementsManager; + } + + public void setInventories(ArrayList 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 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 commands = itemInventory.getCommands(); + if(commands != null && !commands.isEmpty()) { + String commandList = ""; + for(int i=0;i 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 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 items = inventory.getItems(); + for(int i=0;i 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 replaceRequirementsMessageVariable(String kitName, Player player){ + Kit kit = plugin.getKitsManager().getKitByName(kitName); + KitRequirements requirements = kit.getRequirements(); + + MessagesManager msgManager = plugin.getMessagesManager(); + List requirementsMessage = new ArrayList<>(requirements.getMessage()); + List extraRequirements = requirements.getExtraRequirements(); + List 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 lore = new ArrayList(); + for(String l : meta.getLore()) { + lore.add(l.replace("§", "&")); + } + kitItem.setLore(lore); + } + if(meta.hasEnchants()) { + List enchants = new ArrayList(); + for(Map.Entry entry : meta.getEnchants().entrySet()){ + String enchant = entry.getKey().getName(); + int level = entry.getValue(); + enchants.add(enchant+";"+level); + } + kitItem.setEnchants(enchants); + } + Set flags = meta.getItemFlags(); + if(flags != null && !flags.isEmpty()) { + List flagsList = new ArrayList(); + 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 enchants = meta2.getStoredEnchants(); + List enchantsList = new ArrayList(); + for (Map.Entry entry : enchants.entrySet()) { + enchantsList.add(entry.getKey().getName()+";"+entry.getValue().intValue()); + } + if(!enchantsList.isEmpty()) { + kitItem.setBookEnchants(enchantsList); + } + } + } + + List 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 lore = kitItem.getLore(); + if(lore != null) { + List loreCopy = new ArrayList(lore); + for(int i=0;i enchants = kitItem.getEnchants(); + if(enchants != null) { + for(int i=0;i flags = kitItem.getFlags(); + if(flags != null) { + for(int i=0;i bookEnchants = kitItem.getBookEnchants(); + if(bookEnchants != null && !bookEnchants.isEmpty()) { + EnchantmentStorageMeta meta2 = (EnchantmentStorageMeta) item.getItemMeta(); + for(int i=0;i attributes = kitItem.getAttributes(); + item = ItemUtils.setAttributes(plugin,item, attributes); + + List 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 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 enchants = config.contains(path+".enchants") ? config.getStringList(path+".enchants") : null; + List flags = config.contains(path+".item_flags") ? config.getStringList(path+".item_flags") : null; + List bookEnchants = config.contains(path+".book_enchants") ? config.getStringList(path+".book_enchants") : null; + List nbtList = config.contains(path+".nbt") ? config.getStringList(path+".nbt") : null; + List 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 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 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 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 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 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 lore = meta.getLore(); + for(int i=0;i kits; + public KitsManager(PlayerKits2 plugin){ + this.plugin = plugin; + } + + public PlayerKits2 getPlugin() { + return plugin; + } + + public void setPlugin(PlayerKits2 plugin) { + this.plugin = plugin; + } + + public ArrayList getKits() { + return kits; + } + + public void setKits(ArrayList 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 items = new ArrayList<>(); + boolean hasArmor = false; + for(int i=0;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 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 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 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 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; + } + +} diff --git a/src/main/java/pk/ajneb97/managers/MessagesManager.java b/src/main/java/pk/ajneb97/managers/MessagesManager.java new file mode 100644 index 0000000..1e53a04 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/pk/ajneb97/managers/PlayerDataManager.java b/src/main/java/pk/ajneb97/managers/PlayerDataManager.java new file mode 100644 index 0000000..09f0672 --- /dev/null +++ b/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 players; + + public PlayerDataManager(PlayerKits2 plugin){ + this.plugin = plugin; + } + + public ArrayList getPlayers() { + return players; + } + + public void setPlayers(ArrayList 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 { + 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); + } + } + } +} diff --git a/src/main/java/pk/ajneb97/managers/edit/InventoryEditActionsManager.java b/src/main/java/pk/ajneb97/managers/edit/InventoryEditActionsManager.java new file mode 100644 index 0000000..d5b6a24 --- /dev/null +++ b/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 lore = new ArrayList(); + 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 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 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 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 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 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 getKitActionsFromType(Kit kit,String type){ + ArrayList actions = null; + if(type.equals("claim")){ + actions = kit.getClaimActions(); + }else{ + actions = kit.getErrorActions(); + } + return actions; + } +} diff --git a/src/main/java/pk/ajneb97/managers/edit/InventoryEditDisplayManager.java b/src/main/java/pk/ajneb97/managers/edit/InventoryEditDisplayManager.java new file mode 100644 index 0000000..a2fefb9 --- /dev/null +++ b/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 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 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; + } +} diff --git a/src/main/java/pk/ajneb97/managers/edit/InventoryEditKitItemsManager.java b/src/main/java/pk/ajneb97/managers/edit/InventoryEditKitItemsManager.java new file mode 100644 index 0000000..3d49f82 --- /dev/null +++ b/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 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 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 offHandLore = new ArrayList<>(); + offHandLore.add(" "); + offHandLore.add(MessagesManager.getColoredMessage("&c&lRIGHT CLICK &cto remove from offhand")); + ItemMeta meta = item.getItemMeta(); + List 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 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 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); + } + } + } + } +} diff --git a/src/main/java/pk/ajneb97/managers/edit/InventoryEditManager.java b/src/main/java/pk/ajneb97/managers/edit/InventoryEditManager.java new file mode 100644 index 0000000..a54eb9b --- /dev/null +++ b/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 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 getPlayers() { + return players; + } + + public void removeInventoryPlayer(Player player){ + for(int i=0;i lore = new ArrayList(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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 setActionItemLore(ArrayList actions,List lore){ + int max = 20; + if(actions.isEmpty()){ + lore.add(MessagesManager.getColoredMessage("&cNONE")); + }else{ + for(KitAction kitAction : actions){ + String actionLine = kitAction.getAction(); + List separatedActionLine = new ArrayList(); + int currentPos = 0; + for(int i=0;i= 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= 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); + } + } +} diff --git a/src/main/java/pk/ajneb97/managers/edit/InventoryEditPositionManager.java b/src/main/java/pk/ajneb97/managers/edit/InventoryEditPositionManager.java new file mode 100644 index 0000000..7eb4750 --- /dev/null +++ b/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 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 extraLore = new ArrayList<>(); + extraLore.add(" "); + extraLore.add(MessagesManager.getColoredMessage("&a&lTHIS IS THE CURRENT POSITION OF")); + extraLore.add(MessagesManager.getColoredMessage("&a&lTHE KIT.")); + List itemLore = new ArrayList<>(); + if(meta.hasLore()){ + itemLore = new ArrayList<>(meta.getLore()); + } + itemLore.addAll(extraLore); + meta.setLore(itemLore); + item.setItemMeta(meta); + } + + ArrayList 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 lore = new ArrayList(); + 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); + } + } +} diff --git a/src/main/java/pk/ajneb97/managers/edit/InventoryEditRequirementsManager.java b/src/main/java/pk/ajneb97/managers/edit/InventoryEditRequirementsManager.java new file mode 100644 index 0000000..44be601 --- /dev/null +++ b/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 lore = new ArrayList(); + 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(); + 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(); + 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); + } + } +} diff --git a/src/main/java/pk/ajneb97/model/Kit.java b/src/main/java/pk/ajneb97/model/Kit.java new file mode 100644 index 0000000..3b07c47 --- /dev/null +++ b/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 items; + private ArrayList claimActions; + private ArrayList 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 getItems() { + return items; + } + + public void setItems(ArrayList 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 getClaimActions() { + return claimActions; + } + + public void setClaimActions(ArrayList claimActions) { + this.claimActions = claimActions; + } + + public ArrayList getErrorActions() { + return errorActions; + } + + public void setErrorActions(ArrayList 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(); + } +} diff --git a/src/main/java/pk/ajneb97/model/KitAction.java b/src/main/java/pk/ajneb97/model/KitAction.java new file mode 100644 index 0000000..1639f68 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/pk/ajneb97/model/KitRequirements.java b/src/main/java/pk/ajneb97/model/KitRequirements.java new file mode 100644 index 0000000..39ea82d --- /dev/null +++ b/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 extraRequirements; + private List message; + private List actionsOnBuy; + + public KitRequirements(boolean oneTimeRequirements, List extraRequirements, List message, + List 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 getMessage() { + return message; + } + + public void setMessage(List message) { + this.message = message; + } + + public List getActionsOnBuy() { + return actionsOnBuy; + } + + public void setActionsOnBuy(List actionsOnBuy) { + this.actionsOnBuy = actionsOnBuy; + } + + public double getPrice() { + return price; + } + + public void setPrice(double price) { + this.price = price; + } + + public List getExtraRequirements() { + return extraRequirements; + } + + public void setExtraRequirements(List extraRequirements) { + this.extraRequirements = extraRequirements; + } +} diff --git a/src/main/java/pk/ajneb97/model/PlayerData.java b/src/main/java/pk/ajneb97/model/PlayerData.java new file mode 100644 index 0000000..1009b3f --- /dev/null +++ b/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 kits; + + public PlayerData(String name,String uuid){ + this.name = name; + this.uuid = uuid; + this.kits = new ArrayList(); + } + + 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 getKits() { + return kits; + } + + public void setKits(ArrayList 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 slots; + private String slotsString; + private KitItem item; + private String openInventory; + private List commands; + private String type; + + public ItemKitInventory(String slotsString, KitItem item, String openInventory, List commands, String type) { + slots = new ArrayList<>(); + this.slotsString = slotsString; + String[] slotsSep = slotsString.split(";"); + for(int i=0;i getSlots() { + return slots; + } + + public void setSlots(List 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 getCommands() { + return commands; + } + + public void setCommands(List 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; + } +} diff --git a/src/main/java/pk/ajneb97/model/inventory/KitInventory.java b/src/main/java/pk/ajneb97/model/inventory/KitInventory.java new file mode 100644 index 0000000..0055a19 --- /dev/null +++ b/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 items; + + public KitInventory(String name, int slots, String title, List 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 getItems() { + return items; + } + + public void setItems(List items) { + this.items = items; + } + + public int addKitItemOnFirstEmptySlot(String kitName){ + List occupiedSlots = new ArrayList<>(); + for(ItemKitInventory item : items){ + for(int slot : item.getSlots()){ + occupiedSlots.add(slot); + } + } + + for(int i=0;i newSlotList = new ArrayList<>(); + newSlotList.add(slot); + items.add(new ItemKitInventory(slot+"",null,null,null,"kit: "+kitName)); + } +} diff --git a/src/main/java/pk/ajneb97/model/item/KitItem.java b/src/main/java/pk/ajneb97/model/item/KitItem.java new file mode 100644 index 0000000..0cfe763 --- /dev/null +++ b/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 lore; + private short durability; + private int customModelData; + private List enchants; + private List flags; + private List bookEnchants; + private int color; + private List nbt; + //Format: + //;;;; + private List 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 getLore() { + return lore; + } + + public void setLore(List 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 getEnchants() { + return enchants; + } + + public void setEnchants(List enchants) { + this.enchants = enchants; + } + + public List getFlags() { + return flags; + } + + public void setFlags(List 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 getBookEnchants() { + return bookEnchants; + } + + public void setBookEnchants(List bookEnchants) { + this.bookEnchants = bookEnchants; + } + + public List getNbt() { + return nbt; + } + + public void setNbt(List nbt) { + this.nbt = nbt; + } + + public List getAttributes() { + return attributes; + } + + public void setAttributes(List 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 patterns; + private String baseColor; + public KitItemBannerData(List patterns, String baseColor) { + super(); + this.patterns = patterns; + this.baseColor = baseColor; + } + public List getPatterns() { + return patterns; + } + public void setPatterns(List patterns) { + this.patterns = patterns; + } + public String getBaseColor() { + return baseColor; + } + public void setBaseColor(String baseColor) { + this.baseColor = baseColor; + } +} diff --git a/src/main/java/pk/ajneb97/model/item/KitItemBookData.java b/src/main/java/pk/ajneb97/model/item/KitItemBookData.java new file mode 100644 index 0000000..44e8df2 --- /dev/null +++ b/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 pages; + private String author; + private String generation; + private String title; + public KitItemBookData(List pages, String author, String generation, String title) { + super(); + this.pages = pages; + this.author = author; + this.generation = generation; + this.title = title; + } + public List getPages() { + return pages; + } + public void setPages(List 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; + } +} diff --git a/src/main/java/pk/ajneb97/model/item/KitItemFireworkData.java b/src/main/java/pk/ajneb97/model/item/KitItemFireworkData.java new file mode 100644 index 0000000..fc249a8 --- /dev/null +++ b/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 fireworkRocketEffects; + private String fireworkStarEffect; + private int fireworkPower; + public KitItemFireworkData(List fireworkRocketEffects, String fireworkStarEffect, int fireworkPower) { + super(); + this.fireworkRocketEffects = fireworkRocketEffects; + this.fireworkStarEffect = fireworkStarEffect; + this.fireworkPower = fireworkPower; + } + public List getFireworkRocketEffects() { + return fireworkRocketEffects; + } + public void setFireworkRocketEffects(List 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; + } +} diff --git a/src/main/java/pk/ajneb97/model/item/KitItemPotionData.java b/src/main/java/pk/ajneb97/model/item/KitItemPotionData.java new file mode 100644 index 0000000..a0b8511 --- /dev/null +++ b/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 potionEffects; + public KitItemPotionData(boolean upgraded, boolean extended, String potionType, int potionColor, + List 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 getPotionEffects() { + return potionEffects; + } + public void setPotionEffects(List potionEffects) { + this.potionEffects = potionEffects; + } +} diff --git a/src/main/java/pk/ajneb97/model/item/KitItemSkullData.java b/src/main/java/pk/ajneb97/model/item/KitItemSkullData.java new file mode 100644 index 0000000..1f70457 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/pk/ajneb97/model/item/KitItemTrimData.java b/src/main/java/pk/ajneb97/model/item/KitItemTrimData.java new file mode 100644 index 0000000..1307eba --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/pk/ajneb97/tasks/InventoryUpdateTaskManager.java b/src/main/java/pk/ajneb97/tasks/InventoryUpdateTaskManager.java new file mode 100644 index 0000000..bd2e21d --- /dev/null +++ b/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 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 colors = new ArrayList(); + FireworkEffect.Type type = null; + ArrayList fadeColors = new ArrayList(); + 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); + } +} diff --git a/src/main/java/pk/ajneb97/utils/InventoryItem.java b/src/main/java/pk/ajneb97/utils/InventoryItem.java new file mode 100644 index 0000000..a03fa69 --- /dev/null +++ b/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 lore) { + for(int i=0;i getNBT(PlayerKits2 plugin, ItemStack item){ + return plugin.getNmsManager().getNBT(item); + } + + public static ItemStack setNBT(PlayerKits2 plugin, ItemStack item, List 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 potionEffectsList = new ArrayList(); + 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 potionEffects = meta.getCustomEffects(); + for(int i=0;i potionEffects = potionData.getPotionEffects(); + if(potionEffects != null) { + for(int i=0;i bannerPatterns = new ArrayList(); + String baseColor = null; + + List patterns = new ArrayList(); + + 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 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 fireworkRocketEffects = new ArrayList(); + String fireworkStarEffect = null; + int fireworkPower = 0; + + String typeName = item.getType().name(); + boolean isFireworkCharge = false; + List effects = new ArrayList(); + + 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 colors = e.getColors(); + String colorsLine = ""; + for(int i=0;i fadeColors = e.getFadeColors(); + String fadeColorsLine = ""; + for(int i=0;i 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 colorsList = new ArrayList(); + for(int c=0;c fadeColorsList = new ArrayList(); + if(!sep[2].equals("")) { + String[] fadeColors = sep[2].split(","); + for(int c=0;c getAttributes(PlayerKits2 plugin, ItemStack item){ + if(OtherUtils.isLegacy()) { + return plugin.getNmsManager().getAttributes(item); + }else { + //1.13+ + ItemMeta meta = item.getItemMeta(); + if(meta.hasAttributeModifiers()) { + Multimap attributes = meta.getAttributeModifiers(); + Set set = attributes.keySet(); + + List attributeList = new ArrayList(); + for(Attribute a : set) { + Collection 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 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 pages = new ArrayList(); + 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(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 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(pages)); + }else { + ArrayList pagesBaseComponent = new ArrayList(); + 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); + } + } + } +} diff --git a/src/main/java/pk/ajneb97/utils/OtherUtils.java b/src/main/java/pk/ajneb97/utils/OtherUtils.java new file mode 100644 index 0000000..ab75553 --- /dev/null +++ b/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 list){ + for(int i=min;i<=max;i++){ + list.add(i); + } + } +} diff --git a/src/main/java/pk/ajneb97/utils/PlayerUtils.java b/src/main/java/pk/ajneb97/utils/PlayerUtils.java new file mode 100644 index 0000000..f167a1f --- /dev/null +++ b/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=")) { + 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; + } + +} diff --git a/src/main/java/pk/ajneb97/versions/NMSManager.java b/src/main/java/pk/ajneb97/versions/NMSManager.java new file mode 100644 index 0000000..5ba80e6 --- /dev/null +++ b/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 getNBT(ItemStack item){ + List 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 tags = (Set) 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 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 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 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 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= 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(); + } +} diff --git a/src/main/java/pk/ajneb97/versions/ServerVersion.java b/src/main/java/pk/ajneb97/versions/ServerVersion.java new file mode 100644 index 0000000..cf31cb4 --- /dev/null +++ b/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, +} diff --git a/src/main/java/pk/ajneb97/versions/Version.java b/src/main/java/pk/ajneb97/versions/Version.java new file mode 100644 index 0000000..e8589a9 --- /dev/null +++ b/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> classes; + private HashMap 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); + } +} diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml new file mode 100644 index 0000000..00010e1 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/src/main/resources/inventory.yml b/src/main/resources/inventory.yml new file mode 100644 index 0000000..3f81510 --- /dev/null +++ b/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" diff --git a/src/main/resources/kits/diamond.yml b/src/main/resources/kits/diamond.yml new file mode 100644 index 0000000..f707d15 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/src/main/resources/kits/food.yml b/src/main/resources/kits/food.yml new file mode 100644 index 0000000..ad1aa58 --- /dev/null +++ b/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" \ No newline at end of file diff --git a/src/main/resources/kits/iron.yml b/src/main/resources/kits/iron.yml new file mode 100644 index 0000000..83e4b04 --- /dev/null +++ b/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" \ No newline at end of file diff --git a/src/main/resources/messages.yml b/src/main/resources/messages.yml new file mode 100644 index 0000000..beceb63 --- /dev/null +++ b/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 " +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 " +commandCreateError: "&cYou need to use: &7/kit create " +commandDeleteError: "&cYou need to use: &7/kit delete " +commandResetError: "&cYou need to use: &7/kit reset " +commandEditError: "&cYou need to use: &7/kit edit " +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!" + + diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..5172424 --- /dev/null +++ b/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] \ No newline at end of file