message

src/main/java/hu/jgj52/pvpcore/Commands/AcceptDuelCommand.java

@@ -0,0 +1,179 @@
+package hu.jgj52.pvpcore.Commands;
+
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.Database;
+import hu.jgj52.pvpcore.Utils.Kits;
+import hu.jgj52.pvpcore.Utils.SchematicManager;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.title.Title;
+import java.time.Duration;
+
+import java.util.*;
+import java.util.concurrent.ExecutionException;
+
+import static java.util.Collections.min;
+
+public class AcceptDuelCommand implements CommandExecutor, TabCompleter {
+    private final Main plugin;
+
+    public AcceptDuelCommand(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        if (sender instanceof Player player) {
+            if (args.length != 1) {
+                player.sendMessage("§cHasználat: /acceptduel <játékos>");
+                return true;
+            }
+
+
+            Database.QueryResult reqResult = null;
+            try {
+                reqResult = plugin.db.from("pvpcore_duel_requests").eq("player", Objects.requireNonNull(Bukkit.getPlayer(args[0])).getUniqueId()).eq("enemy", player.getUniqueId()).execute().get();
+            } catch (InterruptedException | ExecutionException e) {
+                throw new RuntimeException(e);
+            }
+
+            Map<String, Object> row = reqResult.data.get(0);
+
+            Player enemy = Bukkit.getPlayer(args[0]);
+            if (enemy == null) {
+                player.sendMessage("§cA megadott játékos nem található.");
+                return true;
+            }
+
+            if (reqResult.isEmpty()) {
+                player.sendMessage("§cNincs párbajkérelmed ettől a játékostól.");
+                return true;
+            }
+
+            Kits kitManager = new Kits(plugin);
+            SchematicManager schematic = new SchematicManager(plugin);
+
+            String gamemode = row.get("kit").toString();
+
+            Database.QueryResult result = null;
+            try {
+                result = plugin.db.from("pvpcore_kits")
+                        .eq("name", gamemode)
+                        .execute()
+                        .get();
+            } catch (InterruptedException | ExecutionException e) {
+                throw new RuntimeException(e);
+            }
+
+            Map<String, Object> kitRow = result.data.get(0);
+
+            player.getInventory().clear();
+            enemy.getInventory().clear();
+            World world = Bukkit.getWorld("arenas");
+            boolean survival = Boolean.parseBoolean(kitRow.get("survival").toString());
+            String arena = kitRow.get("arena").toString();
+            int x = Integer.parseInt(kitRow.get("id").toString()) * 1000;
+            int y = 0;
+            int z;
+
+            if (plugin.usedArenas.isEmpty()) {
+                z = 0;
+            } else {
+                z = min(plugin.usedArenas) - 1000;
+            }
+
+            plugin.usedArenas.add(z);
+
+            schematic.placeSchematic(world, x, y, z, arena, true);
+            Location playerLoc = new Location(world, x + 20.5, y, z + 0.5, 90, 0);
+            Location enemyLoc = new Location(world, x - 20.5, y, z + 0.5, -90, 0);
+
+            for (PotionEffect potionEffect : player.getActivePotionEffects()) {
+                player.removePotionEffect(potionEffect.getType());
+            }
+            for (PotionEffect potionEffect : enemy.getActivePotionEffects()) {
+                enemy.removePotionEffect(potionEffect.getType());
+            }
+            player.addPotionEffect(new PotionEffect(PotionEffectType.SLOW_FALLING, 20, 1), true);
+            enemy.addPotionEffect(new PotionEffect(PotionEffectType.SLOW_FALLING, 20, 1), true);
+            player.teleport(playerLoc);
+            enemy.teleport(enemyLoc);
+            try {
+                player.getInventory().setContents(kitManager.getKit(gamemode, player, false));
+                enemy.getInventory().setContents(kitManager.getKit(gamemode, enemy, false));
+            } catch (ExecutionException | InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+            player.setHealth(20D);
+            enemy.setHealth(20D);
+            player.setFoodLevel(20);
+            enemy.setFoodLevel(20);
+            player.setSaturation(5);
+            enemy.setSaturation(5);
+            player.setGameMode(survival ? GameMode.SURVIVAL : GameMode.ADVENTURE);
+            enemy.setGameMode(survival ? GameMode.SURVIVAL : GameMode.ADVENTURE);
+
+            Map<String, Object> duelData = new HashMap<>();
+            duelData.put("player", enemy.getUniqueId());
+            duelData.put("enemy", player.getUniqueId());
+            duelData.put("ft", row.get("ft"));
+            duelData.put("kit", gamemode);
+            duelData.put("started", System.currentTimeMillis());
+
+            plugin.db.from("pvpcore_duels").insert(duelData);
+            plugin.db.from("pvpcore_duel_requests").eq("player", Objects.requireNonNull(Bukkit.getPlayer(args[0])).getUniqueId()).eq("enemy", player.getUniqueId()).delete();
+
+            new BukkitRunnable() {
+                int countdown = 3;
+
+                @Override
+                public void run() {
+                    if (countdown > 0) {
+                        Component titleText = Component.text(String.valueOf(countdown), NamedTextColor.AQUA);
+                        Title title = Title.title(
+                                titleText,
+                                Component.empty(),
+                                Title.Times.times(Duration.ZERO, Duration.ofSeconds(1), Duration.ZERO)
+                        );
+                        player.showTitle(title);
+                        enemy.showTitle(title);
+                        countdown--;
+                    } else {
+                        Title startTitle = Title.title(
+                                Component.text("§eA párbaj megkezdődött!"),
+                                Component.empty(),
+                                Title.Times.times(Duration.ZERO, Duration.ofSeconds(2), Duration.ofSeconds(1))
+                        );
+                        player.showTitle(startTitle);
+                        enemy.showTitle(startTitle);
+                        cancel();
+                    }
+                }
+            }.runTaskTimer(plugin, 0L, 20L);
+
+        }
+
+        return true;
+    }
+
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        return List.of();
+    }
+}

src/main/java/hu/jgj52/pvpcore/Commands/ConnectCommand.java

@@ -0,0 +1,59 @@
+package hu.jgj52.pvpcore.Commands;
+
+import hu.jgj52.pvpcore.Main;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import net.kyori.adventure.text.event.ClickEvent;
+
+public class ConnectCommand implements CommandExecutor, TabCompleter {
+    private final Main plugin;
+
+    public ConnectCommand(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        if (sender instanceof Player player) {
+            String chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()-_=+[]{};:,.<>?/";
+            java.security.SecureRandom rnd = new java.security.SecureRandom();
+            String key = rnd.ints(12, 0, chars.length())
+                    .mapToObj(chars::charAt)
+                    .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
+                    .toString();
+            Map<String, Object> data = new HashMap<>();
+            data.put("key", key);
+            data.put("player", player.getUniqueId());
+            data.put("timestamp", System.currentTimeMillis() + 300000);
+            plugin.db.from("pvpcore_connect").eq("player", player.getUniqueId()).delete();
+            plugin.db.from("pvpcore_connect").insert(data);
+            player.sendMessage(
+                    Component.text("A kulcsod a bejelentkezéshez: ", NamedTextColor.GREEN)
+                            .append(
+                                    Component.text(key, NamedTextColor.YELLOW)
+                                            .clickEvent(ClickEvent.copyToClipboard(key))
+                                            .hoverEvent(Component.text("Kattints a másoláshoz!", NamedTextColor.GRAY))
+                            )
+            );
+
+        }
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        return List.of();
+    }
+}

src/main/java/hu/jgj52/pvpcore/Commands/CreateKitCommand.java

@@ -0,0 +1,45 @@
+package hu.jgj52.pvpcore.Commands;
+
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.Kits;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+
+public class CreateKitCommand implements CommandExecutor, TabCompleter {
+    private final Main plugin;
+
+    public CreateKitCommand(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        if (sender instanceof Player player) {
+            if (args.length == 1) {
+                String base64 = Kits.itemStackArrayToBase64(player.getInventory().getContents());
+
+                Map<String, Object> data = new HashMap<>();
+                data.put("name", args[0]);
+                data.put("content", base64);
+
+                plugin.db.from("pvpcore_kits").insert(data);
+                player.sendMessage("§aKit sikeresen létrehozva!");
+            } else {
+                sender.sendMessage("§cUsage: /createkit <name>");
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        return List.of();
+    }
+}

src/main/java/hu/jgj52/pvpcore/Commands/DenyDuelCommand.java

@@ -0,0 +1,59 @@
+package hu.jgj52.pvpcore.Commands;
+
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.Database;
+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.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.ExecutionException;
+
+public class DenyDuelCommand implements CommandExecutor, TabCompleter {
+    private final Main plugin;
+
+    public DenyDuelCommand(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        if (sender instanceof Player player) {
+            if (args.length != 1) {
+                player.sendMessage("§cHasználat: /denyduel <játékos>");
+                return true;
+            }
+
+            Database.QueryResult reqResult = null;
+            try {
+                reqResult = plugin.db.from("pvpcore_duel_requests").eq("player", Objects.requireNonNull(Bukkit.getPlayer(args[0])).getUniqueId()).eq("enemy", player.getUniqueId()).execute().get();
+            } catch (InterruptedException | ExecutionException e) {
+                throw new RuntimeException(e);
+            }
+
+            if (reqResult.isEmpty()) {
+                player.sendMessage("§cNincs párbajkérelmed.");
+                return true;
+            }
+
+            Player enemy = Bukkit.getPlayer(args[0]);
+            if (enemy == null) {
+                player.sendMessage("§cA megadott játékos nem található.");
+                return true;
+            }
+            plugin.db.from("pvpcore_duel_requests").eq("player", Objects.requireNonNull(Bukkit.getPlayer(args[0])).getUniqueId()).eq("enemy", player.getUniqueId()).delete();
+        }
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        return List.of();
+    }
+}

src/main/java/hu/jgj52/pvpcore/Commands/DuelCommand.java

@@ -0,0 +1,214 @@
+package hu.jgj52.pvpcore.Commands;
+
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.Database;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.bukkit.inventory.meta.SkullMeta;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.profile.PlayerProfile;
+import org.bukkit.profile.PlayerTextures;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ExecutionException;
+
+public class DuelCommand implements CommandExecutor, TabCompleter {
+    private final Main plugin;
+
+    public DuelCommand(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (sender instanceof Player player) {
+
+            if (args.length != 1) {
+                player.sendMessage("§a                        Használat");
+                player.sendMessage("§a----------------------------------------");
+                player.sendMessage("§a/duel [játékos] » Meghívás egy párbajra");
+                return true;
+            }
+
+            Player target = Bukkit.getPlayer(args[0]);
+            if (target == null || !target.isOnline()) {
+                player.sendMessage("§7[§9§lInsane§e§lDuels§7] §7» §cA megadott játékos nem elérhető");
+                return true;
+            }
+
+            if (player.equals(target)) {
+                player.sendMessage("§7[§9§lInsane§e§lDuels§7] §7» §cMagaddal nem párbajozhatsz!");
+                return true;
+            }
+
+            Database.QueryResult result = null;
+            try {
+                result = plugin.db.from("pvpcore_duel_requests").eq("player", player.getUniqueId()).eq("enemy", target.getUniqueId()).execute().get();
+            } catch (InterruptedException | ExecutionException e) {
+                throw new RuntimeException(e);
+            }
+
+            if (!result.isEmpty()) {
+                player.sendMessage("§7[§9§lInsane§e§lDuels§7] §7» §e" + target.getName() + "§9 játékosnak már küldtél párbaj kérelmet.");
+                return true;
+            }
+
+            Inventory gui = Bukkit.createInventory(null, 36, "§9\uD83D\uDDE1 Játékmód Választás");
+            ItemStack vanilla = new ItemStack(Material.END_CRYSTAL);
+            ItemMeta vanillaMeta = vanilla.getItemMeta();
+            vanillaMeta.setDisplayName("§dVanilla");
+
+            ItemStack uhc = new ItemStack(Material.LAVA_BUCKET);
+            ItemMeta uhcMeta = uhc.getItemMeta();
+            uhcMeta.setDisplayName("§cUHC");
+            uhc.setItemMeta(uhcMeta);
+
+            ItemStack pot = new ItemStack(Material.POTION);
+            PotionMeta potMeta = (PotionMeta) pot.getItemMeta();
+            potMeta.setDisplayName("§cPot");
+            potMeta.addCustomEffect(new PotionEffect(PotionEffectType.INSTANT_HEALTH, 20, 0), true);
+            pot.setItemMeta(potMeta);
+
+            ItemStack nethpot = new ItemStack(Material.NETHERITE_HELMET);
+            nethpot.addEnchantment(Enchantment.MENDING, 1);
+            ItemMeta nethpotMeta = nethpot.getItemMeta();
+            nethpotMeta.setDisplayName("§5NethPot");
+            nethpot.setItemMeta(nethpotMeta);
+
+            ItemStack smp = new ItemStack(Material.ENDER_PEARL);
+            ItemMeta smpMeta = smp.getItemMeta();
+            smpMeta.setDisplayName("§2SMP");
+            smp.setItemMeta(smpMeta);
+
+            ItemStack sword = new ItemStack(Material.DIAMOND_SWORD);
+            ItemMeta swordMeta = sword.getItemMeta();
+            swordMeta.setDisplayName("§bSword");
+            sword.setItemMeta(swordMeta);
+
+            ItemStack axe = new ItemStack(Material.DIAMOND_AXE);
+            ItemMeta axeMeta = axe.getItemMeta();
+            axeMeta.setDisplayName("§bAxe");
+            axe.setItemMeta(axeMeta);
+
+            ItemStack mace = new ItemStack(Material.MACE);
+            ItemMeta maceMeta = mace.getItemMeta();
+            maceMeta.setDisplayName("§7Mace");
+            mace.setItemMeta(maceMeta);
+
+            ItemStack cart = new ItemStack(Material.TNT_MINECART);
+            ItemMeta cartMeta = cart.getItemMeta();
+            cartMeta.setDisplayName("§cCart");
+            cart.setItemMeta(cartMeta);
+
+            ItemStack diasmp = new ItemStack(Material.CHORUS_FRUIT);
+            ItemMeta diasmpMeta = diasmp.getItemMeta();
+            diasmpMeta.setDisplayName("§dDiaSMP");
+            diasmp.setItemMeta(diasmpMeta);
+
+            ItemStack shieldlessuhc = new ItemStack(Material.PLAYER_HEAD);
+            SkullMeta skullMeta = (SkullMeta) shieldlessuhc.getItemMeta();
+
+            PlayerProfile profile = Bukkit.createProfile(UUID.randomUUID(), "Schicsial");
+
+            try {
+                PlayerTextures textures = profile.getTextures();
+
+                textures.setSkin(new URL("https://textures.minecraft.net/texture/566a87460173adf067cb356ae200d030504378c552e3428b4774c4c11a599c24"));
+
+                profile.setTextures(textures);
+
+                skullMeta.setPlayerProfile((com.destroystokyo.paper.profile.PlayerProfile) profile);
+
+                skullMeta.setDisplayName("§eShieldlessUHC");
+                shieldlessuhc.setItemMeta(skullMeta);
+            } catch (MalformedURLException e) {
+                e.printStackTrace();
+            }
+
+            ItemStack pirosuveg = new ItemStack(Material.RED_STAINED_GLASS_PANE);
+            ItemMeta pirosuvegMeta = pirosuveg.getItemMeta();
+            pirosuvegMeta.setDisplayName("§cItt még nincs játékmód!");
+            pirosuveg.setItemMeta(pirosuvegMeta);
+
+            ItemStack kekuveg = new ItemStack(Material.BLUE_STAINED_GLASS_PANE);
+            ItemMeta kekuvegMeta = kekuveg.getItemMeta();
+            kekuvegMeta.setDisplayName(" ");
+            kekuveg.setItemMeta(kekuvegMeta);
+
+            ItemStack ft = new ItemStack(Material.PAPER);
+            ItemMeta ftMeta = ft.getItemMeta();
+            ftMeta.setDisplayName("First To");
+            ft.setItemMeta(ftMeta);
+
+            gui.setItem(0, kekuveg);
+            gui.setItem(1, kekuveg);
+            gui.setItem(2, kekuveg);
+            gui.setItem(3, kekuveg);
+            gui.setItem(4, ft);
+            gui.setItem(5, kekuveg);
+            gui.setItem(6, kekuveg);
+            gui.setItem(7, kekuveg);
+            gui.setItem(8, kekuveg);
+            gui.setItem(9, kekuveg);
+            gui.setItem(10, vanilla);
+            gui.setItem(11, uhc);
+            gui.setItem(12, pot);
+            gui.setItem(13, nethpot);
+            gui.setItem(14, smp);
+            gui.setItem(15, sword);
+            gui.setItem(16, axe);
+            gui.setItem(17, kekuveg);
+            gui.setItem(18, kekuveg);
+            gui.setItem(19, mace);
+            gui.setItem(20, cart);
+            gui.setItem(21, diasmp);
+            gui.setItem(22, shieldlessuhc);
+            gui.setItem(23, pirosuveg);
+            gui.setItem(24, pirosuveg);
+            gui.setItem(25, pirosuveg);
+            gui.setItem(26, kekuveg);
+            gui.setItem(27, kekuveg);
+            gui.setItem(28, kekuveg);
+            gui.setItem(29, kekuveg);
+            gui.setItem(30, kekuveg);
+            gui.setItem(31, kekuveg);
+            gui.setItem(32, kekuveg);
+            gui.setItem(33, kekuveg);
+            gui.setItem(34, kekuveg);
+            gui.setItem(35, kekuveg);
+
+            player.openInventory(gui);
+            Map<String, Object> data = new HashMap<>();
+            data.put("player", player.getUniqueId());
+            data.put("enemy", target.getUniqueId());
+            data.put("timestamp", System.currentTimeMillis() + 60000);
+            plugin.db.from("pvpcore_duel_requests").insert(data);
+        }
+        return true;
+    }
+
+    @Override
+    public List<String> onTabComplete(CommandSender sender, Command command, String s, String[] args) {
+        if (args.length == 1) {
+            return null;
+        }
+        return List.of();
+    }
+}

src/main/java/hu/jgj52/pvpcore/Commands/EditKitCommand.java

@@ -0,0 +1,122 @@
+package hu.jgj52.pvpcore.Commands;
+
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.Database;
+import hu.jgj52.pvpcore.Utils.Kits;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+
+public class EditKitCommand implements CommandExecutor, TabCompleter {
+    private final Main plugin;
+
+    public EditKitCommand(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        if (sender instanceof Player player) {
+            if (args.length > 0) {
+                try {
+                    Database.QueryResult result = plugin.db.from("pvpcore_kits").eq("name", args[0]).execute().get();
+                    if (!result.isEmpty()) {
+                        Kits kitManager = new Kits(plugin);
+                        Inventory gui = Bukkit.createInventory(null, 27, "Kit Editor");
+
+                        ItemStack saveKit = new ItemStack(Material.GREEN_STAINED_GLASS_PANE);
+                        ItemMeta saveMeta = saveKit.getItemMeta();
+
+                        ItemStack infoItem = new ItemStack(Material.WHITE_STAINED_GLASS_PANE);
+                        ItemMeta infoMeta = infoItem.getItemMeta();
+                        infoMeta.setDisplayName("§fEdit Kit: " + args[0]);
+                        infoItem.setItemMeta(infoMeta);
+
+                        ItemStack undoKit = new ItemStack(Material.RED_STAINED_GLASS_PANE);
+                        ItemMeta undoMeta = undoKit.getItemMeta();
+                        saveMeta.setDisplayName("§aSave Kit");
+                        saveKit.setItemMeta(saveMeta);
+                        undoMeta.setDisplayName("§cUndo Changes");
+                        undoKit.setItemMeta(undoMeta);
+
+                        gui.setItem(0, saveKit);
+                        gui.setItem(1, saveKit);
+                        gui.setItem(2, saveKit);
+                        gui.setItem(6, undoKit);
+                        gui.setItem(7, undoKit);
+                        gui.setItem(8, undoKit);
+                        gui.setItem(9, saveKit);
+                        gui.setItem(10, saveKit);
+                        gui.setItem(11, saveKit);
+                        gui.setItem(15, undoKit);
+                        gui.setItem(16, undoKit);
+                        gui.setItem(17, undoKit);
+                        gui.setItem(18, saveKit);
+                        gui.setItem(19, saveKit);
+                        gui.setItem(20, saveKit);
+                        gui.setItem(24, undoKit);
+                        gui.setItem(25, undoKit);
+                        gui.setItem(26, undoKit);
+                        gui.setItem(3, infoItem);
+                        gui.setItem(4, infoItem);
+                        gui.setItem(5, infoItem);
+                        gui.setItem(12, infoItem);
+                        gui.setItem(13, infoItem);
+                        gui.setItem(14, infoItem);
+                        gui.setItem(21, infoItem);
+                        gui.setItem(22, infoItem);
+                        gui.setItem(23, infoItem);
+                        Inventory inv = player.getInventory();
+                        inv.clear();
+
+                        inv.setContents(kitManager.getKit(args[0], player, false));
+
+                        player.openInventory(gui);
+                    }
+
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                } catch (ExecutionException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        if (args.length == 1) {
+            try {
+                Database.QueryResult results = plugin.db.from("pvpcore_kits").execute().get();
+                if (!results.isEmpty()) {
+                    List<String> kitNames = new java.util.ArrayList<>();
+                    for (Map<String, Object> row : results.data) {
+                        Object nameObj = row.get("name");
+                        if (nameObj != null) {
+                            kitNames.add(nameObj.toString());
+                        }
+                    }
+                    return kitNames;
+                }
+            } catch (InterruptedException | ExecutionException e) {
+                e.printStackTrace();
+            }
+        }
+        return List.of();
+    }
+}

src/main/java/hu/jgj52/pvpcore/Commands/LeaveCommand.java

@@ -0,0 +1,33 @@
+package hu.jgj52.pvpcore.Commands;
+
+import hu.jgj52.pvpcore.Main;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+public class LeaveCommand implements CommandExecutor, TabCompleter {
+    private final Main plugin;
+
+    public LeaveCommand(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        if (sender instanceof Player player) {
+            player.setHealth(0);
+        }
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        return List.of();
+    }
+}

src/main/java/hu/jgj52/pvpcore/Commands/ResetArenasCommand.java

@@ -0,0 +1,34 @@
+package hu.jgj52.pvpcore.Commands;
+
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.WorldReset;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ResetArenasCommand implements CommandExecutor, TabCompleter {
+    private final Main plugin;
+
+    public ResetArenasCommand(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        WorldReset worldReset = new WorldReset(plugin);
+        worldReset.recreateArenaWorld();
+        plugin.usedArenas = new ArrayList<>();
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        return List.of();
+    }
+}

src/main/java/hu/jgj52/pvpcore/Commands/SpectateCommand.java

@@ -0,0 +1,51 @@
+package hu.jgj52.pvpcore.Commands;
+
+import hu.jgj52.pvpcore.Main;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.metadata.FixedMetadataValue;
+
+public class SpectateCommand implements CommandExecutor {
+    private final Main plugin;
+
+    public SpectateCommand(Main plugin) {
+        this.plugin = plugin;
+    }
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+
+        if (!(sender instanceof Player)) {
+            sender.sendMessage("nem vagy jatekos ez nem cica");
+            return true;
+        }
+
+        Player player = (Player) sender;
+
+        if (args.length != 1) {
+            player.sendMessage("§7[§9§lInsane§e§lDuels§7] §7» §cKell egy játékosnév is dumbass");
+            return true;
+        }
+
+        Player target = Bukkit.getPlayer(args[0]);
+        if (target == null || !target.isOnline()) {
+            player.sendMessage("§7[§9§lInsane§e§lDuels§7] §7» §cA játékos jelenleg nem elérhető");
+            return true;
+        }
+
+        if (!target.hasMetadata("DuelingWith") || target.getMetadata("DuelingWith").isEmpty()) {
+            player.sendMessage("§7[§9§lInsane§e§lDuels§7] §7» §cEz a játékos jelenleg nincs párbajban");
+            return true;
+        }
+
+        player.setMetadata("IsSpectating", new FixedMetadataValue(plugin, true));
+        player.setGameMode(GameMode.SPECTATOR);
+        player.teleport(target);
+        player.sendMessage("§7[§9§lInsane§e§lDuels§7] §7» §aMostantól §e" + target.getName() + "§a párbaját figyeled!");
+
+        return true;
+    }
+}

src/main/java/hu/jgj52/pvpcore/Listeners/DuelEndListener.java

@@ -0,0 +1,225 @@
+package hu.jgj52.pvpcore.Listeners;
+
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.Database;
+import hu.jgj52.pvpcore.Utils.Kits;
+import hu.jgj52.pvpcore.Utils.SchematicManager;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.*;
+import org.bukkit.entity.Firework;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.ExecutionException;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.title.Title;
+import org.bukkit.inventory.meta.FireworkMeta;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import static java.util.Collections.min;
+
+public class DuelEndListener implements Listener {
+    private final Main plugin;
+
+    public DuelEndListener(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void onDuelEnd(PlayerDeathEvent e) throws ExecutionException, InterruptedException {
+        Player player = e.getPlayer();
+        boolean isEnemy = false;
+        Database.QueryResult result = plugin.db.from("pvpcore_duels").eq("player", player.getUniqueId()).execute().get();
+        if (result.isEmpty()) {
+            result = plugin.db.from("pvpcore_duels").eq("enemy", player.getUniqueId()).execute().get();
+            isEnemy = true;
+        }
+
+        Map<String, Object> row = result.data.get(0);
+        if (!result.isEmpty() && (Integer.parseInt(row.get("ft").toString()) - 1 == Integer.parseInt(row.get("player_points").toString()) || Integer.parseInt(row.get("ft").toString()) - 1 == Integer.parseInt(row.get("enemy_points").toString()))) {
+            Player enemy = Bukkit.getPlayer(UUID.fromString(isEnemy ? row.get("player").toString() : row.get("enemy").toString()));
+            player.getInventory().clear();
+            enemy.getInventory().clear();
+            e.setCancelled(true);
+            player.setGameMode(GameMode.SPECTATOR);
+            Location playerLoc = player.getLocation();
+
+            Title winnerTitle = Title.title(
+                    Component.text("§6🗡 §eMegnyerted a párbajt!"),
+                    Component.empty(),
+                    Title.Times.times(Duration.ofMillis(500), Duration.ofSeconds(3), Duration.ofMillis(1000))
+            );
+
+            Title loserTitle = Title.title(
+                    Component.text("§4🗡 §cElvesztetted a párbajt!"),
+                    Component.empty(),
+                    Title.Times.times(Duration.ofMillis(500), Duration.ofSeconds(3), Duration.ofMillis(1000))
+            );
+
+            for (int i = 0; i < 3; i++) {
+                int delay = i * 10;
+                Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                    Firework firework = playerLoc.getWorld().spawn(playerLoc, Firework.class);
+                    FireworkMeta meta = firework.getFireworkMeta();
+
+                    FireworkEffect effect = FireworkEffect.builder()
+                            .with(FireworkEffect.Type.BURST)
+                            .withColor(
+                                    Color.fromRGB(2437522),
+                                    Color.fromRGB(14602026),
+                                    Color.fromRGB(6719955)
+                            )
+                            .build();
+
+                    meta.addEffect(effect);
+                    meta.setPower((int) 0.5);
+                    firework.setFireworkMeta(meta);
+                }, delay);
+            }
+
+            player.showTitle(loserTitle);
+            enemy.showTitle(winnerTitle);
+
+            Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                try {
+                    plugin.tpToSpawn(player);
+                    plugin.tpToSpawn(enemy);
+                } catch (Exception exception) {
+                    exception.printStackTrace();
+                }
+            }, 60L);
+
+            Map<String, Object> data = new HashMap<>();
+            data.put("player", row.get("player"));
+            data.put("enemy", row.get("enemy"));
+            data.put("ft", row.get("ft"));
+            data.put("kit", row.get("kit"));
+            data.put("winner", enemy.getUniqueId());
+            data.put("loser", player.getUniqueId());
+            data.put("player_points", row.get("player_points"));
+            data.put("enemy_points", row.get("enemy_points"));
+            data.put("started", row.get("started"));
+            data.put("ended", System.currentTimeMillis());
+            plugin.db.from("pvpcore_duel_logs").insert(data);
+            plugin.db.from("pvpcore_duels").eq(isEnemy ? "enemy" : "player", player.getUniqueId()).eq(isEnemy ? "player" : "enemy", enemy.getUniqueId()).delete();
+        } else if (!result.isEmpty() && Integer.parseInt(row.get("ft").toString()) - 1 != Integer.parseInt(row.get("player_points").toString()) && Integer.parseInt(row.get("ft").toString()) - 1 != Integer.parseInt(row.get("enemy_points").toString())) {
+            Player enemy = Bukkit.getPlayer(UUID.fromString(isEnemy ? row.get("player").toString() : row.get("enemy").toString()));
+            Kits kitManager = new Kits(plugin);
+            SchematicManager schematic = new SchematicManager(plugin);
+
+            String gamemode = row.get("kit").toString();
+
+            Database.QueryResult kitResult = null;
+            try {
+                kitResult = plugin.db.from("pvpcore_kits")
+                        .eq("name", gamemode)
+                        .execute()
+                        .get();
+            } catch (InterruptedException | ExecutionException ex) {
+                throw new RuntimeException(ex);
+            }
+
+            Map<String, Object> kitRow = kitResult.data.get(0);
+
+            player.getInventory().clear();
+            enemy.getInventory().clear();
+            e.setCancelled(true);
+            World world = Bukkit.getWorld("arenas");
+            boolean survival = Boolean.parseBoolean(kitRow.get("survival").toString());
+            String arena = kitRow.get("arena").toString();
+            int x = Integer.parseInt(kitRow.get("id").toString()) * 1000;
+            int y = 0;
+            int z;
+
+            if (plugin.usedArenas.isEmpty()) {
+                z = 0;
+            } else {
+                z = min(plugin.usedArenas) - 1000;
+            }
+
+            plugin.usedArenas.add(z);
+
+            schematic.placeSchematic(world, x, y, z, arena, true);
+            Location playerLoc = new Location(world, x + 20.5, y, z + 0.5, 90, 0);
+            Location enemyLoc = new Location(world, x - 20.5, y, z + 0.5, -90, 0);
+
+            for (PotionEffect potionEffect : player.getActivePotionEffects()) {
+                player.removePotionEffect(potionEffect.getType());
+            }
+            for (PotionEffect potionEffect : enemy.getActivePotionEffects()) {
+                enemy.removePotionEffect(potionEffect.getType());
+            }
+            player.addPotionEffect(new PotionEffect(PotionEffectType.SLOW_FALLING, 20, 1), true);
+            enemy.addPotionEffect(new PotionEffect(PotionEffectType.SLOW_FALLING, 20, 1), true);
+
+            Bukkit.getScheduler().runTaskLater(plugin, () -> {player.teleport(playerLoc);enemy.teleport(enemyLoc);}, 2L);
+
+            try {
+                player.getInventory().setContents(kitManager.getKit(gamemode, player, false));
+                enemy.getInventory().setContents(kitManager.getKit(gamemode, enemy, false));
+            } catch (ExecutionException | InterruptedException ex) {
+                throw new RuntimeException(ex);
+            }
+            player.setHealth(20D);
+            enemy.setHealth(20D);
+            player.setFoodLevel(20);
+            enemy.setFoodLevel(20);
+            player.setSaturation(5);
+            enemy.setSaturation(5);
+            player.setGameMode(survival ? GameMode.SURVIVAL : GameMode.ADVENTURE);
+            enemy.setGameMode(survival ? GameMode.SURVIVAL : GameMode.ADVENTURE);
+
+            Map<String, Object> duelData = new HashMap<>();
+            duelData.put("player", row.get("player"));
+            duelData.put("enemy", row.get("enemy"));
+            duelData.put("ft", row.get("ft"));
+            duelData.put("kit", row.get("kit"));
+            duelData.put(isEnemy ? "player_points" : "enemy_points", Integer.parseInt(row.get(isEnemy ? "player_points" : "enemy_points").toString()) + 1);
+            duelData.put("started", row.get("started"));
+
+            plugin.db.from("pvpcore_duels").update(duelData);
+
+            new BukkitRunnable() {
+                int countdown = 3;
+
+                @Override
+                public void run() {
+                    if (countdown > 0) {
+                        Component titleText = Component.text(String.valueOf(countdown), NamedTextColor.AQUA);
+                        Title title = Title.title(
+                                titleText,
+                                Component.empty(),
+                                Title.Times.times(Duration.ZERO, Duration.ofSeconds(1), Duration.ZERO)
+                        );
+                        player.showTitle(title);
+                        enemy.showTitle(title);
+                        countdown--;
+                    } else {
+                        Title startTitle = Title.title(
+                                Component.text("§eA párbaj megkezdődött!"),
+                                Component.empty(),
+                                Title.Times.times(Duration.ZERO, Duration.ofSeconds(2), Duration.ofSeconds(1))
+                        );
+                        player.showTitle(startTitle);
+                        enemy.showTitle(startTitle);
+                        cancel();
+                    }
+                }
+            }.runTaskTimer(plugin, 0L, 20L);
+        } else {
+            e.setCancelled(true);
+            plugin.tpToSpawn(player);
+        }
+    }
+}

src/main/java/hu/jgj52/pvpcore/Listeners/DuelRequestListener.java

@@ -0,0 +1,122 @@
+package hu.jgj52.pvpcore.Listeners;
+
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.Database;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+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.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import net.md_5.bungee.api.chat.ClickEvent;
+import net.md_5.bungee.api.chat.ComponentBuilder;
+import net.md_5.bungee.api.chat.TextComponent;
+import net.md_5.bungee.api.chat.HoverEvent;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ExecutionException;
+
+public class DuelRequestListener implements Listener {
+    private final Main plugin;
+
+    public DuelRequestListener(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) {
+        if (!(event.getWhoClicked() instanceof Player player)) return;
+
+        if (event.getView().getTitle().equals("§9\uD83D\uDDE1 Játékmód Választás")) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onDuelRequest(InventoryClickEvent e) throws ExecutionException, InterruptedException {
+        Player player = (Player) e.getWhoClicked();
+
+        if (!e.getView().getTitle().equals("§9\uD83D\uDDE1 Játékmód Választás")) return;
+
+        ItemStack clickedItem = e.getCurrentItem();
+        if (clickedItem == null || clickedItem.getType() == Material.AIR) return;
+
+        if (clickedItem.getType() == Material.RED_STAINED_GLASS_PANE || clickedItem.getType() == Material.BLUE_STAINED_GLASS_PANE) return;
+
+        if (clickedItem.getType() == Material.PAPER) {
+            int count = clickedItem.getAmount();
+            if (e.getClick() == ClickType.LEFT) {
+                count++;
+            } else if (e.getClick() == ClickType.RIGHT) {
+                count--;
+            }
+            clickedItem.setAmount(count);
+            return;
+        }
+
+        if (e.getClick() != ClickType.LEFT) return;
+
+        Database.QueryResult result = plugin.db.from("pvpcore_duel_requests").eq("player", player.getUniqueId()).execute().get();
+
+        Map<String, Object> row = result.data.get(0);
+
+        if (!result.isEmpty()) {
+            e.setCancelled(true);
+
+            Player target = Bukkit.getPlayer(UUID.fromString(row.get("enemy").toString()));
+
+            if (target == null) {
+                player.sendMessage("§cA meghívott játékos nincs jelen a szerveren.");
+                return;
+            }
+
+            String gamemode = ChatColor.stripColor(clickedItem.getItemMeta().getDisplayName().toLowerCase());
+
+            Map<String, Object> data = new HashMap<>();
+            data.put("kit", gamemode);
+            data.put("ft", e.getView().getInventory(0).getItem(4).getAmount());
+            plugin.db.from("pvpcore_duel_requests").update(data);
+
+            TextComponent accept = new TextComponent("§a[✔ Elfogadás]");
+            accept.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/acceptduel " + player.getName()));
+            accept.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
+                    new ComponentBuilder("§a✔ Nyomj rá az elfogadáshoz!").create()));
+
+            TextComponent decline = new TextComponent("§c[❌ Elutasítás]");
+            decline.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/denyduel " + player.getName()));
+            decline.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
+                    new ComponentBuilder("§c❌ Nyomj rá az elutasításhoz!").create()));
+
+            TextComponent info = new TextComponent("§7ℹ");
+            info.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,
+                    new ComponentBuilder("§7Játékmód: §a" + ChatColor.stripColor(clickedItem.getItemMeta().getDisplayName()) + "\n")
+                            .append("§7Aréna: §aFootball\n")
+                            .append("§7Ellenfél: §e" + player.getName() + "\n")
+                            .append("§7Opciók:\n")
+                            .append("§8- §7Kör: §e1\n")
+                            .create()));
+
+            TextComponent fullMessage = new TextComponent();
+            fullMessage.addExtra(accept);
+            fullMessage.addExtra(" ");
+            fullMessage.addExtra(decline);
+            fullMessage.addExtra(" ");
+            fullMessage.addExtra(info);
+
+            target.sendMessage("§8-----------------------------------------------------");
+            target.sendMessage("§c\uD83D\uDDE1 §e" + player.getName() + " §7küldött egy " + clickedItem.getItemMeta().getDisplayName().toLowerCase() + " §7párbaj kérést!");
+            target.sendMessage(" ");
+            target.spigot().sendMessage(fullMessage);
+            target.sendMessage("§8-----------------------------------------------------");
+
+            player.closeInventory();
+        }
+    }
+}

src/main/java/hu/jgj52/pvpcore/Listeners/KitListener.java

@@ -0,0 +1,114 @@
+package hu.jgj52.pvpcore.Listeners;
+
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.Database;
+import hu.jgj52.pvpcore.Utils.Kits;
+import net.kyori.adventure.text.Component;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.inventory.ItemStack;
+import org.postgresql.util.PGobject;
+
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+
+public class KitListener implements Listener {
+    private final Main plugin;
+    private final Kits kitsUtil;
+
+    public KitListener(Main plugin) {
+        this.plugin = plugin;
+        this.kitsUtil = new Kits(plugin);
+    }
+
+    @EventHandler
+    public void onInventoryClick(InventoryClickEvent event) throws ExecutionException, InterruptedException, SQLException {
+        if (!(event.getWhoClicked() instanceof Player player)) return;
+
+        if (event.getClickedInventory() == event.getView().getTopInventory()
+                && event.getView().title().equals(Component.text("Kit Editor"))) {
+            event.setCancelled(true);
+
+            boolean saveSlot = (0 <= event.getSlot() && event.getSlot() <= 2)
+                    || (9 <= event.getSlot() && event.getSlot() <= 11)
+                    || (18 <= event.getSlot() && event.getSlot() <= 20);
+
+            boolean cancelSlot = (6 <= event.getSlot() && event.getSlot() <= 8)
+                    || (15 <= event.getSlot() && event.getSlot() <= 17)
+                    || (24 <= event.getSlot() && event.getSlot() <= 26);
+
+            if (saveSlot) {
+                String gamemode = event.getClickedInventory().getItem(13).getItemMeta().getDisplayName().split(" ")[2];
+
+                ItemStack[] kit = kitsUtil.getKit(gamemode, player, true);
+
+                String base64Inv = Kits.itemStackArrayToBase64(player.getInventory().getContents());
+
+                Database.QueryResult plResult = plugin.db.from("pvpcore_players")
+                        .eq("uuid", player.getUniqueId())
+                        .execute()
+                        .get();
+
+                Map<String, String> playerKits;
+                if (!plResult.isEmpty()) {
+                    Map<String, Object> playerRow = plResult.data.get(0);
+                    Object kitsObj = playerRow.get("kits");
+                    if (kitsObj != null) {
+                        String playerKitsStr = kitsObj instanceof PGobject pg ? pg.getValue() : kitsObj.toString();
+                        java.lang.reflect.Type type = new com.google.gson.reflect.TypeToken<Map<String, String>>() {}.getType();
+                        playerKits = new com.google.gson.Gson().fromJson(playerKitsStr, type);
+                    } else {
+                        playerKits = new HashMap<>();
+                    }
+                } else {
+                    playerKits = new HashMap<>();
+                }
+
+                Database.QueryResult result = plugin.db.from("pvpcore_kits")
+                        .eq("name", gamemode)
+                        .execute()
+                        .get();
+
+                Map<String, Object> kitRow = result.data.get(0);
+
+                playerKits.put(kitRow.get("id").toString(), base64Inv);
+
+                Map<String, Object> data = new HashMap<>();
+                PGobject jsonObj = new PGobject();
+                jsonObj.setType("json");
+                jsonObj.setValue(new com.google.gson.Gson().toJson(playerKits));
+                data.put("kits", jsonObj);
+
+                plugin.db.from("pvpcore_players")
+                        .eq("uuid", player.getUniqueId())
+                        .update(data)
+                        .thenAccept(r -> player.sendMessage("§aA kit el lett mentve."))
+                        .exceptionally(ex -> {
+                            ex.printStackTrace();
+                            player.sendMessage("§cHiba történt a kit mentése közben.");
+                            return null;
+                        });
+
+                player.closeInventory();
+            } else if (cancelSlot) {
+                player.closeInventory();
+                player.sendMessage("§cA kited nem került mentésre.");
+            }
+        }
+    }
+
+    @EventHandler
+    public void onInventoryClose(InventoryCloseEvent event) {
+        if (!(event.getPlayer() instanceof Player player)) return;
+        if (event.getInventory() == event.getView().getTopInventory()
+                && event.getView().title().equals(Component.text("Kit Editor"))) {
+            player.getInventory().clear();
+        }
+    }
+}

src/main/java/hu/jgj52/pvpcore/Listeners/PlayerListener.java

@@ -0,0 +1,118 @@
+package hu.jgj52.pvpcore.Listeners;
+
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.Database;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.title.Title;
+import org.bukkit.*;
+import org.bukkit.entity.Firework;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.inventory.meta.FireworkMeta;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.metadata.MetadataValue;
+
+import java.time.Duration;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ExecutionException;
+
+public class PlayerListener implements Listener {
+    private final Main plugin;
+
+    public PlayerListener(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void onJoin(PlayerJoinEvent event) throws ExecutionException, InterruptedException {
+        Database.QueryResult result = plugin.db.from("pvpcore_players")
+                .eq("uuid", event.getPlayer().getUniqueId())
+                .execute()
+                .get();
+        Map<String, Object> data = new HashMap<>();
+        data.put("admin", event.getPlayer().hasPermission("pvpcore.admin"));
+        data.put("name", event.getPlayer().getName());
+        if (result.isEmpty()) {
+            data.put("uuid", event.getPlayer().getUniqueId());
+            plugin.db.from("pvpcore_players").insert(data);
+        } else {
+            plugin.db.from("pvpcore_players").eq("uuid", event.getPlayer().getUniqueId()).update(data);
+        }
+        plugin.tpToSpawn(event.getPlayer());
+    }
+
+    @EventHandler
+    public void onLeave(PlayerQuitEvent e) throws ExecutionException, InterruptedException {
+        Player player = e.getPlayer();
+        boolean isEnemy = false;
+        Database.QueryResult result = plugin.db.from("pvpcore_duels").eq("player", player.getUniqueId()).execute().get();
+        if (result.isEmpty()) {
+            result = plugin.db.from("pvpcore_duels").eq("enemy", player.getUniqueId()).execute().get();
+            isEnemy = true;
+        }
+
+
+        if (!result.isEmpty()) {
+            Map<String, Object> row = result.data.get(0);
+            Player enemy = Bukkit.getPlayer(UUID.fromString(isEnemy ? row.get("player").toString() : row.get("enemy").toString()));
+            enemy.getInventory().clear();
+            Location playerLoc = player.getLocation();
+
+            Title winnerTitle = Title.title(
+                    Component.text("§6🗡 §eMegnyerted a párbajt!"),
+                    Component.empty(),
+                    Title.Times.times(Duration.ofMillis(500), Duration.ofSeconds(3), Duration.ofMillis(1000))
+            );
+
+            for (int i = 0; i < 3; i++) {
+                int delay = i * 10;
+                Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                    Firework firework = playerLoc.getWorld().spawn(playerLoc, Firework.class);
+                    FireworkMeta meta = firework.getFireworkMeta();
+
+                    FireworkEffect effect = FireworkEffect.builder()
+                            .with(FireworkEffect.Type.BURST)
+                            .withColor(
+                                    Color.fromRGB(2437522),
+                                    Color.fromRGB(14602026),
+                                    Color.fromRGB(6719955)
+                            )
+                            .build();
+
+                    meta.addEffect(effect);
+                    meta.setPower((int) 0.5);
+                    firework.setFireworkMeta(meta);
+                }, delay);
+            }
+
+            enemy.showTitle(winnerTitle);
+
+            Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                try {
+                    plugin.tpToSpawn(enemy);
+                } catch (Exception exception) {
+                    exception.printStackTrace();
+                }
+            }, 60L);
+
+            Map<String, Object> data = new HashMap<>();
+            data.put("player", row.get("player"));
+            data.put("enemy", row.get("enemy"));
+            data.put("ft", row.get("ft"));
+            data.put("kit", row.get("kit"));
+            data.put("winner", enemy.getUniqueId());
+            data.put("loser", player.getUniqueId());
+            data.put("player_points", row.get("player_points"));
+            data.put("enemy_points", row.get("enemy_points"));
+            data.put("started", row.get("started"));
+            data.put("ended", System.currentTimeMillis());
+            plugin.db.from("pvpcore_duel_logs").insert(data);
+            plugin.db.from("pvpcore_duels").eq(isEnemy ? "enemy" : "player", player.getUniqueId()).eq(isEnemy ? "player" : "enemy", enemy.getUniqueId()).delete();
+        }
+    }
+}

src/main/java/hu/jgj52/pvpcore/Listeners/SpectatorListener.java

@@ -0,0 +1,35 @@
+package hu.jgj52.pvpcore.Listeners;
+
+import hu.jgj52.pvpcore.Main;
+import org.bukkit.GameMode;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
+import org.bukkit.metadata.FixedMetadataValue;
+
+public class SpectatorListener implements Listener {
+
+    private final Main plugin;
+
+    public SpectatorListener(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void onSpectatorTeleport(PlayerTeleportEvent event) {
+        if (event.getPlayer().getGameMode() == GameMode.SPECTATOR && event.getCause() == TeleportCause.SPECTATE) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        Player player = event.getPlayer();
+        if (player.hasMetadata("IsSpectating") && player.getMetadata("IsSpectating").get(0).asBoolean()) {
+            player.setMetadata("IsSpectating", new FixedMetadataValue(plugin, false));
+        }
+    }
+}

src/main/java/hu/jgj52/pvpcore/Main.java

@@ -0,0 +1,111 @@
+package hu.jgj52.pvpcore;
+
+import hu.jgj52.pvpcore.Commands.*;
+import hu.jgj52.pvpcore.Listeners.*;
+import hu.jgj52.pvpcore.Utils.*;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.util.*;
+import java.util.concurrent.ExecutionException;
+
+public final class Main extends JavaPlugin {
+
+    public Database db = new Database(getConfig().getString("database.host"), getConfig().getInt("database.port"), getConfig().getString("database.database"), getConfig().getString("database.user"), getConfig().getString("database.password"));
+
+    public void tpToSpawn(Player player) {
+        Location spawn = new Location(Bukkit.getWorld("world"), 0.5, 3, 0.5, 0, 0);
+        for (PotionEffect potionEffect : player.getActivePotionEffects()) {
+            player.removePotionEffect(potionEffect.getType());
+        }
+        player.addPotionEffect(new PotionEffect(PotionEffectType.SLOW_FALLING, 20, 1), true);
+        player.setHealth(20D);
+        player.setFoodLevel(20);
+        player.setSaturation(5);
+        player.setGameMode(GameMode.ADVENTURE);
+        player.teleport(spawn);
+        player.getInventory().clear();
+    }
+
+    /*páblik statik vojd rimúvPléjerFromDuel() {;
+      ;
+    };*/
+
+    @Override
+    public void onEnable() {
+        getConfig().options().copyDefaults(true);
+        saveDefaultConfig();
+        saveConfig();
+
+        getCommand("duel").setExecutor(new DuelCommand(this));
+        getCommand("acceptduel").setExecutor(new AcceptDuelCommand(this));
+        getCommand("denyduel").setExecutor(new DenyDuelCommand(this));
+        getCommand("editkit").setExecutor(new EditKitCommand(this));
+        getCommand("resetarenas").setExecutor(new ResetArenasCommand(this));
+        getCommand("spectate").setExecutor(new SpectateCommand(this));
+        getCommand("leave").setExecutor(new LeaveCommand(this));
+        getCommand("createkit").setExecutor(new CreateKitCommand(this));
+        getCommand("connect").setExecutor(new ConnectCommand(this));
+
+        getServer().getPluginManager().registerEvents(new DuelRequestListener(this), this);
+        getServer().getPluginManager().registerEvents(new KitListener(this), this);
+        getServer().getPluginManager().registerEvents(new DuelEndListener(this), this);
+        getServer().getPluginManager().registerEvents(new PlayerListener(this), this);
+        getServer().getPluginManager().registerEvents(new SpectatorListener(this), this);
+
+        WorldReset worldReset = new WorldReset(this);
+        worldReset.recreateArenaWorld();
+
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                try {
+                    Database.QueryResult result = db.from("pvpcore_duel_requests").execute().get();
+                    if (!result.isEmpty()) {
+                        Map<String, Object> row = result.data.get(0);
+                        if (Long.parseLong(row.get("timestamp").toString()) <= System.currentTimeMillis()) {
+                            db.from("pvpcore_duel_requests").eq("timestamp", row.get("timestamp")).delete();
+                            Player player = Bukkit.getPlayer(UUID.fromString(row.get("player").toString()));
+                            Player enemy = Bukkit.getPlayer(UUID.fromString(row.get("enemy").toString()));
+                            player.sendMessage("§cLejárt a párbajkérelmed " + enemy.getName() + " ellen!");
+                            enemy.sendMessage("§c" + player.getName() + "-nak lejárt a párbajkérelme!");
+                        }
+                    }
+                } catch (InterruptedException | ExecutionException e) {
+                    throw new RuntimeException(e);
+                }
+                try {
+                    Database.QueryResult result = db.from("pvpcore_connect").execute().get();
+                    if (!result.isEmpty()) {
+                        Map<String, Object> row = result.data.get(0);
+                        if (Long.parseLong(row.get("timestamp").toString()) <= System.currentTimeMillis()) {
+                            db.from("pvpcore_connect").eq("timestamp", row.get("timestamp")).delete();
+                            Player player = Bukkit.getPlayer(UUID.fromString(row.get("player").toString()));
+                            player.sendMessage("§cLejárt a bejelentkezési kulcsod!");
+                        }
+                    }
+                } catch (InterruptedException | ExecutionException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }.runTaskTimer(this, 100L, 100L);
+
+        db.from("pvpcore_duels").delete();
+        db.from("pvpcore_duel_requests").delete();
+        db.from("pvpcore_connect").delete();
+    }
+
+    @Override
+    public void onDisable() {
+        //hi
+    }
+
+    public List<Integer> usedArenas = new ArrayList<>();
+}

src/main/java/hu/jgj52/pvpcore/Utils/Database.java

@@ -0,0 +1,373 @@
+package hu.jgj52.pvpcore.Utils;
+
+import java.sql.*;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+
+public class Database {
+    private final HikariDataSource dataSource;
+    private final ExecutorService executor;
+
+    public Database(String host, int port, String database, String username, String password) {
+        this.executor = Executors.newFixedThreadPool(4);
+
+        HikariConfig config = new HikariConfig();
+        config.setJdbcUrl(String.format("jdbc:postgresql://%s:%d/%s", host, port, database));
+        config.setUsername(username);
+        config.setPassword(password);
+        config.setMaximumPoolSize(10);
+        config.setMinimumIdle(2);
+        config.setConnectionTimeout(30000);
+        config.setIdleTimeout(600000);
+        config.setMaxLifetime(1800000);
+
+        config.setDriverClassName("org.postgresql.Driver");
+
+        try {
+            Class.forName("org.postgresql.Driver");
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException("PostgreSQL Driver not found in classpath", e);
+        }
+
+        this.dataSource = new HikariDataSource(config);
+    }
+
+
+    public QueryBuilder from(String table) {
+        return new QueryBuilder(this.dataSource, table);
+    }
+
+    public CompletableFuture<QueryResult> query(String sql, Object... params) {
+        return CompletableFuture.supplyAsync(() -> {
+            try (Connection conn = dataSource.getConnection();
+                 PreparedStatement stmt = conn.prepareStatement(sql)) {
+
+                for (int i = 0; i < params.length; i++) {
+                    stmt.setObject(i + 1, params[i]);
+                }
+
+                ResultSet rs = stmt.executeQuery();
+                List<Map<String, Object>> data = new ArrayList<>();
+
+                ResultSetMetaData metaData = rs.getMetaData();
+                int columnCount = metaData.getColumnCount();
+
+                while (rs.next()) {
+                    Map<String, Object> row = new HashMap<>();
+                    for (int i = 1; i <= columnCount; i++) {
+                        row.put(metaData.getColumnName(i), rs.getObject(i));
+                    }
+                    data.add(row);
+                }
+
+                return new QueryResult(data, null);
+            } catch (SQLException e) {
+                return new QueryResult(new ArrayList<>(), e.getMessage());
+            }
+        }, executor);
+    }
+
+    public void close() {
+        if (dataSource != null && !dataSource.isClosed()) {
+            dataSource.close();
+        }
+        if (executor != null && !executor.isShutdown()) {
+            executor.shutdown();
+        }
+    }
+
+    public static class QueryBuilder {
+        private final HikariDataSource dataSource;
+        private final ExecutorService executor = Executors.newCachedThreadPool();
+        private String table;
+        private String selected = "*";
+        private List<FilterClause> filters = new ArrayList<>();
+        private String orderClause = "";
+
+        public QueryBuilder(HikariDataSource dataSource, String table) {
+            this.dataSource = dataSource;
+            this.table = "\"" + table + "\"";
+        }
+
+        private QueryBuilder(HikariDataSource dataSource) {
+            this.dataSource = dataSource;
+        }
+
+        public QueryBuilder select(String columns) {
+            QueryBuilder newBuilder = this.clone();
+            newBuilder.selected = columns;
+            return newBuilder;
+        }
+
+        public QueryBuilder eq(String column, Object value) {
+            QueryBuilder newBuilder = this.clone();
+            newBuilder.filters.add(new FilterClause(column, value));
+            return newBuilder;
+        }
+
+        public QueryBuilder order(String column, boolean ascending) {
+            QueryBuilder newBuilder = this.clone();
+            newBuilder.orderClause = String.format("ORDER BY \"%s\" %s", column, ascending ? "ASC" : "DESC");
+            return newBuilder;
+        }
+
+        public QueryBuilder order(String column) {
+            return order(column, true);
+        }
+
+        public QueryBuilder clone() {
+            QueryBuilder newBuilder = new QueryBuilder(this.dataSource);
+            newBuilder.table = this.table;
+            newBuilder.selected = this.selected;
+            newBuilder.filters = new ArrayList<>(this.filters);
+            newBuilder.orderClause = this.orderClause;
+            return newBuilder;
+        }
+
+        private WhereClause buildWhereClause() {
+            List<String> conditions = new ArrayList<>();
+            List<Object> values = new ArrayList<>();
+
+            for (int i = 0; i < filters.size(); i++) {
+                FilterClause filter = filters.get(i);
+                conditions.add(String.format("\"%s\" = ?", filter.column));
+                values.add(filter.value);
+            }
+
+            String where = conditions.isEmpty() ? "" : "WHERE " + String.join(" AND ", conditions);
+            return new WhereClause(where, values);
+        }
+
+        public CompletableFuture<QueryResult> single() {
+            return CompletableFuture.supplyAsync(() -> {
+                WhereClause whereClause = buildWhereClause();
+                String sql = String.format("SELECT %s FROM %s %s LIMIT 1", selected, table, whereClause.where);
+
+                try (Connection conn = dataSource.getConnection();
+                     PreparedStatement stmt = conn.prepareStatement(sql)) {
+
+                    for (int i = 0; i < whereClause.values.size(); i++) {
+                        stmt.setObject(i + 1, whereClause.values.get(i));
+                    }
+
+                    ResultSet rs = stmt.executeQuery();
+
+                    if (rs.next()) {
+                        ResultSetMetaData metaData = rs.getMetaData();
+                        int columnCount = metaData.getColumnCount();
+                        Map<String, Object> row = new HashMap<>();
+
+                        for (int i = 1; i <= columnCount; i++) {
+                            row.put(metaData.getColumnName(i), rs.getObject(i));
+                        }
+
+                        return new QueryResult(Arrays.asList(row), null);
+                    }
+
+                    return new QueryResult(new ArrayList<>(), null);
+                } catch (SQLException e) {
+                    return new QueryResult(new ArrayList<>(), e.getMessage());
+                }
+            }, executor);
+        }
+
+        public CompletableFuture<QueryResult> delete() {
+            return CompletableFuture.supplyAsync(() -> {
+                WhereClause whereClause = buildWhereClause();
+                String sql = String.format("DELETE FROM %s %s RETURNING *", table, whereClause.where);
+
+                try (Connection conn = dataSource.getConnection();
+                     PreparedStatement stmt = conn.prepareStatement(sql)) {
+
+                    for (int i = 0; i < whereClause.values.size(); i++) {
+                        stmt.setObject(i + 1, whereClause.values.get(i));
+                    }
+
+                    ResultSet rs = stmt.executeQuery();
+                    List<Map<String, Object>> data = new ArrayList<>();
+
+                    ResultSetMetaData metaData = rs.getMetaData();
+                    int columnCount = metaData.getColumnCount();
+
+                    while (rs.next()) {
+                        Map<String, Object> row = new HashMap<>();
+                        for (int i = 1; i <= columnCount; i++) {
+                            row.put(metaData.getColumnName(i), rs.getObject(i));
+                        }
+                        data.add(row);
+                    }
+
+                    return new QueryResult(data, null);
+                } catch (SQLException e) {
+                    return new QueryResult(new ArrayList<>(), e.getMessage());
+                }
+            }, executor);
+        }
+
+        public CompletableFuture<QueryResult> insert(Map<String, Object> data) {
+            return CompletableFuture.supplyAsync(() -> {
+                List<String> keys = new ArrayList<>(data.keySet());
+                List<Object> values = new ArrayList<>(data.values());
+
+                String columns = String.join(", ", keys);
+                String placeholders = String.join(", ", Collections.nCopies(keys.size(), "?"));
+                String sql = String.format("INSERT INTO %s (%s) VALUES (%s) RETURNING *", table, columns, placeholders);
+
+                try (Connection conn = dataSource.getConnection();
+                     PreparedStatement stmt = conn.prepareStatement(sql)) {
+
+                    for (int i = 0; i < values.size(); i++) {
+                        stmt.setObject(i + 1, values.get(i));
+                    }
+
+                    ResultSet rs = stmt.executeQuery();
+                    List<Map<String, Object>> result = new ArrayList<>();
+
+                    ResultSetMetaData metaData = rs.getMetaData();
+                    int columnCount = metaData.getColumnCount();
+
+                    while (rs.next()) {
+                        Map<String, Object> row = new HashMap<>();
+                        for (int i = 1; i <= columnCount; i++) {
+                            row.put(metaData.getColumnName(i), rs.getObject(i));
+                        }
+                        result.add(row);
+                    }
+
+                    return new QueryResult(result, null);
+                } catch (SQLException e) {
+                    return new QueryResult(new ArrayList<>(), e.getMessage());
+                }
+            }, executor);
+        }
+
+        public CompletableFuture<QueryResult> update(Map<String, Object> data) {
+            return CompletableFuture.supplyAsync(() -> {
+                if (data == null || data.isEmpty()) {
+                    return new QueryResult(new ArrayList<>(), "No update data provided");
+                }
+
+                WhereClause whereClause = buildWhereClause();
+
+                List<String> setClauses = new ArrayList<>();
+                List<Object> setValues = new ArrayList<>();
+
+                for (Map.Entry<String, Object> entry : data.entrySet()) {
+                    setClauses.add(String.format("\"%s\" = ?", entry.getKey()));
+                    setValues.add(entry.getValue());
+                }
+
+                List<Object> allValues = new ArrayList<>(setValues);
+                allValues.addAll(whereClause.values);
+
+                String sql = String.format("UPDATE %s SET %s %s RETURNING *",
+                        table, String.join(", ", setClauses), whereClause.where);
+
+                try (Connection conn = dataSource.getConnection();
+                     PreparedStatement stmt = conn.prepareStatement(sql)) {
+
+                    for (int i = 0; i < allValues.size(); i++) {
+                        stmt.setObject(i + 1, allValues.get(i));
+                    }
+
+                    ResultSet rs = stmt.executeQuery();
+                    List<Map<String, Object>> result = new ArrayList<>();
+
+                    ResultSetMetaData metaData = rs.getMetaData();
+                    int columnCount = metaData.getColumnCount();
+
+                    while (rs.next()) {
+                        Map<String, Object> row = new HashMap<>();
+                        for (int i = 1; i <= columnCount; i++) {
+                            row.put(metaData.getColumnName(i), rs.getObject(i));
+                        }
+                        result.add(row);
+                    }
+
+                    return new QueryResult(result, null);
+                } catch (SQLException e) {
+                    return new QueryResult(new ArrayList<>(), e.getMessage());
+                }
+            }, executor);
+        }
+
+        public CompletableFuture<QueryResult> execute() {
+            return CompletableFuture.supplyAsync(() -> {
+                WhereClause whereClause = buildWhereClause();
+                String sql = String.format("SELECT %s FROM %s %s %s", selected, table, whereClause.where, orderClause);
+
+                try (Connection conn = dataSource.getConnection();
+                     PreparedStatement stmt = conn.prepareStatement(sql)) {
+
+                    for (int i = 0; i < whereClause.values.size(); i++) {
+                        stmt.setObject(i + 1, whereClause.values.get(i));
+                    }
+
+                    ResultSet rs = stmt.executeQuery();
+                    List<Map<String, Object>> data = new ArrayList<>();
+
+                    ResultSetMetaData metaData = rs.getMetaData();
+                    int columnCount = metaData.getColumnCount();
+
+                    while (rs.next()) {
+                        Map<String, Object> row = new HashMap<>();
+                        for (int i = 1; i <= columnCount; i++) {
+                            row.put(metaData.getColumnName(i), rs.getObject(i));
+                        }
+                        data.add(row);
+                    }
+
+                    return new QueryResult(data, null);
+                } catch (SQLException e) {
+                    return new QueryResult(new ArrayList<>(), e.getMessage());
+                }
+            }, executor);
+        }
+    }
+
+    public static class QueryResult {
+        public final List<Map<String, Object>> data;
+        public final String error;
+
+        public QueryResult(List<Map<String, Object>> data, String error) {
+            this.data = data;
+            this.error = error;
+        }
+
+        public boolean hasError() {
+            return error != null;
+        }
+
+        public boolean isEmpty() {
+            return data == null || data.isEmpty();
+        }
+
+        public Map<String, Object> first() {
+            return isEmpty() ? null : data.get(0);
+        }
+    }
+
+    private static class FilterClause {
+        final String column;
+        final Object value;
+
+        FilterClause(String column, Object value) {
+            this.column = column;
+            this.value = value;
+        }
+    }
+
+    private static class WhereClause {
+        final String where;
+        final List<Object> values;
+
+        WhereClause(String where, List<Object> values) {
+            this.where = where;
+            this.values = values;
+        }
+    }
+}

src/main/java/hu/jgj52/pvpcore/Utils/Kits.java

@@ -0,0 +1,100 @@
+package hu.jgj52.pvpcore.Utils;
+
+import hu.jgj52.pvpcore.Main;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.io.BukkitObjectInputStream;
+import org.bukkit.util.io.BukkitObjectOutputStream;
+import org.postgresql.util.PGobject;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Base64;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+
+public class Kits {
+    private final Main plugin;
+
+    public Kits(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    public static String itemStackArrayToBase64(ItemStack[] items) {
+        try {
+            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
+            try (BukkitObjectOutputStream out = new BukkitObjectOutputStream(byteOut)) {
+                out.writeInt(items.length);
+                for (ItemStack item : items) {
+                    out.writeObject(item);
+                }
+            }
+            return Base64.getEncoder().encodeToString(byteOut.toByteArray());
+        } catch (IOException e) {
+            e.printStackTrace();
+            return "";
+        }
+    }
+
+    public static ItemStack[] itemStackArrayFromBase64(String data) {
+        try {
+            byte[] bytes = Base64.getDecoder().decode(data);
+            try (BukkitObjectInputStream in = new BukkitObjectInputStream(new ByteArrayInputStream(bytes))) {
+                int size = in.readInt();
+                ItemStack[] items = new ItemStack[size];
+                for (int i = 0; i < size; i++) {
+                    items[i] = (ItemStack) in.readObject();
+                }
+                return items;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return new ItemStack[0];
+        }
+    }
+
+    public ItemStack[] getKit(String gamemode, Player player, boolean defaultKit) throws ExecutionException, InterruptedException {
+        Database.QueryResult result = plugin.db.from("pvpcore_kits")
+                .eq("name", gamemode)
+                .execute()
+                .get();
+
+        if (result.isEmpty()) return new ItemStack[0];
+
+        Map<String, Object> kitRow = result.data.get(0);
+        String kitId = kitRow.get("id").toString();
+        String kitString = (String) kitRow.get("content");
+
+        if (!defaultKit) {
+            Database.QueryResult pl = plugin.db.from("pvpcore_players")
+                    .eq("uuid", player.getUniqueId())
+                    .execute()
+                    .get();
+
+            if (!pl.isEmpty()) {
+                Map<String, Object> playerRow = pl.data.get(0);
+                Object kitsObj = playerRow.get("kits");
+                if (kitsObj != null) {
+                    try {
+                        String playerKitsStr = kitsObj instanceof PGobject pg ? pg.getValue() : kitsObj.toString();
+                        if (!playerKitsStr.isEmpty()) {
+                            com.google.gson.Gson gson = new com.google.gson.Gson();
+                            java.lang.reflect.Type type = new com.google.gson.reflect.TypeToken<Map<String, String>>() {}.getType();
+                            Map<String, String> playerKits = gson.fromJson(playerKitsStr, type);
+                            if (playerKits.containsKey(kitId)) {
+                                kitString = playerKits.get(kitId);
+                            }
+                        }
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+        }
+
+        if (kitString == null || kitString.isEmpty()) return new ItemStack[0];
+
+        return itemStackArrayFromBase64(kitString);
+    }
+}

src/main/java/hu/jgj52/pvpcore/Utils/SchematicManager.java

@@ -0,0 +1,99 @@
+package hu.jgj52.pvpcore.Utils;
+
+import com.sk89q.worldedit.EditSession;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.extent.clipboard.Clipboard;
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormat;
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormats;
+import com.sk89q.worldedit.extent.clipboard.io.ClipboardReader;
+import com.sk89q.worldedit.function.operation.Operation;
+import com.sk89q.worldedit.function.operation.Operations;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.session.ClipboardHolder;
+import com.sk89q.worldedit.world.block.BlockTypes;
+import hu.jgj52.pvpcore.Main;
+import org.bukkit.Location;
+import org.bukkit.World;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+public class SchematicManager {
+    private final Main plugin;
+
+    public SchematicManager(Main plugin) {
+        this.plugin = plugin;
+    }
+
+    public boolean placeSchematic(World world, int x, int y, int z, String schematicName, boolean air) {
+        File schematicFile = new File(plugin.getDataFolder() + File.separator + "schematics", schematicName + ".schem");
+
+        if (!schematicFile.exists()) {
+            plugin.getLogger().warning("Schematic file not found: " + schematicFile.getAbsolutePath());
+            return false;
+        }
+
+        ClipboardFormat format = ClipboardFormats.findByFile(schematicFile);
+        if (format == null) {
+            plugin.getLogger().warning("Unknown schematic format for file: " + schematicFile.getAbsolutePath());
+            return false;
+        }
+
+        try (FileInputStream fis = new FileInputStream(schematicFile);
+             ClipboardReader reader = format.getReader(fis)) {
+
+            Clipboard clipboard = reader.read();
+            com.sk89q.worldedit.world.World weWorld = BukkitAdapter.adapt(world);
+
+            try (EditSession editSession = WorldEdit.getInstance().newEditSession(weWorld)) {
+                Operation operation = new ClipboardHolder(clipboard)
+                        .createPaste(editSession)
+                        .to(BlockVector3.at(x, y, z))
+                        .ignoreAirBlocks(air)
+                        .build();
+
+                Operations.complete(operation);
+                editSession.flushSession();
+                return true;
+            }
+        } catch (IOException e) {
+            plugin.getLogger().severe("Error reading schematic file: " + e.getMessage());
+            e.printStackTrace();
+        } catch (Exception e) {
+            plugin.getLogger().severe("Error placing schematic: " + e.getMessage());
+            e.printStackTrace();
+        }
+
+        return false;
+    }
+
+    public boolean removeSchematic(World world, Location loc1, Location loc2) {
+        try {
+            com.sk89q.worldedit.world.World weWorld = BukkitAdapter.adapt(world);
+
+            int minX = Math.min(loc1.getBlockX(), loc2.getBlockX());
+            int maxX = Math.max(loc1.getBlockX(), loc2.getBlockX());
+            int minY = Math.min(loc1.getBlockY(), loc2.getBlockY());
+            int maxY = Math.max(loc1.getBlockY(), loc2.getBlockY());
+            int minZ = Math.min(loc1.getBlockZ(), loc2.getBlockZ());
+            int maxZ = Math.max(loc1.getBlockZ(), loc2.getBlockZ());
+
+            BlockVector3 min = BlockVector3.at(minX, minY, minZ);
+            BlockVector3 max = BlockVector3.at(maxX, maxY, maxZ);
+            CuboidRegion region = new CuboidRegion(weWorld, min, max);
+
+            try (EditSession editSession = WorldEdit.getInstance().newEditSession(weWorld)) {
+                editSession.setBlocks(region, BlockTypes.AIR.getDefaultState());
+                editSession.flushSession();
+                return true;
+            }
+        } catch (Exception e) {
+            plugin.getLogger().severe("Error removing schematic: " + e.getMessage());
+            e.printStackTrace();
+            return false;
+        }
+    }
+}

src/main/java/hu/jgj52/pvpcore/Utils/WorldReset.java

@@ -0,0 +1,134 @@
+package hu.jgj52.pvpcore.Utils;
+
+import org.bukkit.*;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+import java.io.File;
+
+public class WorldReset {
+    private Plugin plugin;
+
+    public WorldReset(Plugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public final String[] metadatas = {"DuelingWith", "ArenaLoc", "Frozen", "DuelRequest", "DueledBy", "DueledWithGamemode", "IsSpectating"};
+
+    public boolean recreateArenaWorld() {
+        String worldName = "arenas";
+
+        try {
+            removeArenaWorld(worldName);
+
+            Bukkit.getScheduler().runTaskLater(plugin, () -> {
+                createArenaWorld(worldName);
+            }, 20L);
+
+            return true;
+
+        } catch (Exception e) {
+            plugin.getLogger().severe("Error recreating arena world: " + e.getMessage());
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    private boolean removeArenaWorld(String worldName) {
+        try {
+            World world = Bukkit.getWorld(worldName);
+
+            if (world != null) {
+
+                world.getPlayers().forEach(player -> {
+                    Location spawn = new Location(Bukkit.getWorld("world"), 0, 3, 0, 0, 0);
+                    for (PotionEffect potionEffect : player.getActivePotionEffects()) {
+                        player.removePotionEffect(potionEffect.getType());
+                    }
+                    player.addPotionEffect(new PotionEffect(PotionEffectType.SLOW_FALLING, 20, 1), true);
+                    player.setHealth(20D);
+                    player.setFoodLevel(20);
+                    player.setSaturation(5);
+                    player.setGameMode(GameMode.ADVENTURE);
+                    player.teleport(spawn);
+                    for (String key : metadatas) {
+                        for (MetadataValue value : player.getMetadata(key)) {
+                            if (value.getOwningPlugin() == plugin) {
+                                player.removeMetadata(key, plugin);
+                                break;
+                            }
+                        }
+                    }
+                    player.sendMessage("§cszia resetel a map szoval tunes");
+                });
+
+                boolean unloaded = Bukkit.unloadWorld(world, false);
+
+                if (unloaded) {
+                    File worldFolder = new File(Bukkit.getWorldContainer(), worldName);
+                    if (worldFolder.exists()) {
+                        deleteDirectory(worldFolder);
+                    }
+
+                    return true;
+                } else {
+                    plugin.getLogger().warning("Failed to unload arena world.");
+                    return false;
+                }
+            } else {
+                return true;
+            }
+        } catch (Exception e) {
+            plugin.getLogger().severe("Error removing arena world: " + e.getMessage());
+            return false;
+        }
+    }
+
+    private boolean createArenaWorld(String worldName) {
+        try {
+            WorldCreator creator = new WorldCreator(worldName)
+                    .type(WorldType.FLAT)
+                    .environment(World.Environment.NORMAL)
+                    .generateStructures(false)
+                    .generatorSettings("{\"layers\":[{\"block\":\"air\",\"height\":1}],\"biome\":\"plains\"}");
+
+            World world = creator.createWorld();
+
+            if (world != null) {
+                world.setSpawnFlags(false, false);
+                world.setTime(6000);
+                world.setGameRule(GameRule.DO_DAYLIGHT_CYCLE, false);
+                world.setStorm(false);
+                world.setThundering(false);
+                world.setGameRule(GameRule.DO_WEATHER_CYCLE, false);
+                return true;
+            } else {
+                plugin.getLogger().severe("Failed to create arena world!");
+                return false;
+            }
+
+        } catch (Exception e) {
+            plugin.getLogger().severe("Error creating arena world: " + e.getMessage());
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    private boolean deleteDirectory(File directory) {
+        if (directory.exists()) {
+            File[] files = directory.listFiles();
+            if (files != null) {
+                for (File file : files) {
+                    if (file.isDirectory()) {
+                        deleteDirectory(file);
+                    } else {
+                        file.delete();
+                    }
+                }
+            }
+        }
+        return directory.delete();
+    }
+}

src/main/resources/plugin.yml

@@ -0,0 +1,20 @@
+name: PvPCore
+version: '1.0'
+main: hu.jgj52.pvpcore.Main
+api-version: '1.21'
+authors: [ JGJ52 ]
+libraries:
+  - 'org.postgresql:postgresql:42.7.7'
+  - 'com.zaxxer:HikariCP:7.0.2'
+commands:
+  duel:
+  acceptduel:
+  denyduel:
+  editkit:
+  resetarenas:
+    permission: pvpcore.resetarenas
+  spectate:
+  leave:
+  createkit:
+    permission: pvpcore.createkit
+  connect: