update

dependency-reduced-pom.xml

@@ -1,10 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
-  <groupId>lnmpro</groupId>
+  <groupId>hu.jgj52.pvpcore</groupId>
-  <artifactId>InsaneDuels</artifactId>
+  <artifactId>PvPCore</artifactId>
-  <name>InsaneDuels</name>
+  <name>PvPCore</name>
-  <version>1.0-SNAPSHOT</version>
+  <version>1.0</version>
   <build>
     <defaultGoal>clean package</defaultGoal>
     <resources>
@@ -73,6 +73,12 @@
       <version>2.13.0</version>
       <scope>provided</scope>
     </dependency>
+    <dependency>
+      <groupId>org.mvplugins.multiverse.core</groupId>
+      <artifactId>multiverse-core</artifactId>
+      <version>5.1.2</version>
+      <scope>provided</scope>
+    </dependency>
   </dependencies>
   <properties>
     <java.version>21</java.version>

pom.xml

@@ -4,12 +4,12 @@
          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
-    <groupId>lnmpro</groupId>
+    <groupId>hu.jgj52.pvpcore</groupId>
-    <artifactId>InsaneDuels</artifactId>
+    <artifactId>PvPCore</artifactId>
-    <version>1.0-SNAPSHOT</version>
+    <version>1.0</version>
     <packaging>jar</packaging>
 
-    <name>InsaneDuels</name>
+    <name>PvPCore</name>
 
     <properties>
         <java.version>21</java.version>
@@ -97,5 +97,17 @@
             <version>5.1.2</version>
             <scope>provided</scope>
         </dependency>
+
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>5.0.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>42.6.0</version>
+        </dependency>
     </dependencies>
 </project>

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

@@ -1,8 +1,9 @@
-package lnmpro.Commands;
+package hu.jgj52.pvpcore.Commands;
 
-import lnmpro.Main;
+import hu.jgj52.pvpcore.Main;
-import lnmpro.Utils.Kits;
+import hu.jgj52.pvpcore.Utils.Database;
-import lnmpro.Utils.SchematicManager;
+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;
@@ -23,9 +24,8 @@ import net.kyori.adventure.text.Component;
 import net.kyori.adventure.title.Title;
 import java.time.Duration;
 
-import java.util.List;
+import java.util.*;
-import java.util.Map;
+import java.util.concurrent.ExecutionException;
-import java.util.UUID;
 
 import static java.util.Collections.min;
 
@@ -44,107 +44,64 @@ public class AcceptDuelCommand implements CommandExecutor, TabCompleter {
                 return true;
             }
 
-            Map<UUID, Main.DuelRequestData> requests = plugin.duelRequests.get(player.getUniqueId());
+
-            if (requests == null) {
+            Database.QueryResult reqResult = null;
-                player.sendMessage("§cNincs párbajkérelmed.");
+            try {
-                return true;
+                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;
             }
 
-            Main.DuelRequestData requestData = requests.get(enemy.getUniqueId());
+            if (reqResult.isEmpty()) {
-
-            if (requestData == null) {
                 player.sendMessage("§cNincs párbajkérelmed ettől a játékostól.");
                 return true;
             }
 
-            if ((System.currentTimeMillis() - requestData.timestamp()) > 60000) {
-                requests.remove(enemy.getUniqueId());
-                if (requests.isEmpty()) {
-                    plugin.duelRequests.remove(player.getUniqueId());
-                }
-                player.sendMessage("§cEz a párbajkérelem lejárt.");
-                return true;
-            }
-
-
             Kits kitManager = new Kits(plugin);
             SchematicManager schematic = new SchematicManager(plugin);
 
-            String gamemode = requestData.gamemode();
+            String gamemode = row.get("kit").toString();
-            plugin.duelRequests.remove(player.getUniqueId());
-            plugin.duelRequests.remove(enemy.getUniqueId());
 
+            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();
-
-            int x = 0;
-            String arena = "";
-            boolean survival = false;
-
-            if (gamemode.equals("uhc")) {
-                x = 1000;
-                arena = "football";
-                survival = true;
-            } else if (gamemode.equals("pot")) {
-                x = 0;
-                arena = "";
-
-            } else if (gamemode.equals("nethpot")) {
-                x = 0;
-                arena = "";
-
-            } else if (gamemode.equals("smp")) {
-                x = 0;
-                arena = "";
-
-            } else if (gamemode.equals("sword")) {
-                x = 1400;
-                arena = "football";
-            } else if (gamemode.equals("axe")) {
-                x = 1500;
-                arena = "football";
-            } else if (gamemode.equals("mace")) {
-                x = 0;
-                arena = "";
-            } else if (gamemode.equals("cart")) {
-                x = 0;
-                arena = "";
-                survival = true;
-
-            } else if (gamemode.equals("diasmp")) {
-                x = 1800;
-                arena = "football";
-                survival = true;
-            } else if (gamemode.equals("shieldlessuhc")) {
-                x = 0;
-                arena = "";
-                survival = true;
-
-            }
-            player.getInventory().setContents(kitManager.getKit(gamemode, player));
-            enemy.getInventory().setContents(kitManager.getKit(gamemode, enemy));
             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 = -2000;
+                z = 0;
             } else {
-                z = min(plugin.usedArenas) - 100;
+                z = min(plugin.usedArenas) - 1000;
             }
 
             plugin.usedArenas.add(z);
 
             schematic.placeSchematic(world, x, y, z, arena, true);
-            Location playerLoc = new Location(world, x + 19.5, y, z + 0.5, 90, 0);
+            Location playerLoc = new Location(world, x + 20.5, y, z + 0.5, 90, 0);
-            Location enemyLoc = new Location(world, x - 17.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());
@@ -156,6 +113,12 @@ public class AcceptDuelCommand implements CommandExecutor, TabCompleter {
             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);
@@ -165,10 +128,15 @@ public class AcceptDuelCommand implements CommandExecutor, TabCompleter {
             player.setGameMode(survival ? GameMode.SURVIVAL : GameMode.ADVENTURE);
             enemy.setGameMode(survival ? GameMode.SURVIVAL : GameMode.ADVENTURE);
 
-            player.setMetadata("DuelingWith", new FixedMetadataValue(plugin, enemy.getUniqueId()));
+            Map<String, Object> duelData = new HashMap<>();
-            enemy.setMetadata("DuelingWith", new FixedMetadataValue(plugin, player.getUniqueId()));
+            duelData.put("player", enemy.getUniqueId());
-            player.setMetadata("ArenaLoc", new FixedMetadataValue(plugin, new Location(world, x, y, z)));
+            duelData.put("enemy", player.getUniqueId());
-            enemy.setMetadata("ArenaLoc", new FixedMetadataValue(plugin, new Location(world, x, y, z)));
+            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();
 
             player.setMetadata("Frozen", new FixedMetadataValue(plugin, true));
             enemy.setMetadata("Frozen", new FixedMetadataValue(plugin, true));
@@ -203,9 +171,8 @@ public class AcceptDuelCommand implements CommandExecutor, TabCompleter {
                 }
             }.runTaskTimer(plugin, 0L, 20L);
 
-        } else {
-            sender.sendMessage("nem vagy player nem fog sikerulni");
         }
+
         return true;
     }
 

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

@@ -1,6 +1,7 @@
-package lnmpro.Commands;
+package hu.jgj52.pvpcore.Commands;
 
-import lnmpro.Main;
+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;
@@ -9,7 +10,7 @@ import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.List;
+import java.util.*;
 
 public class CreateKitCommand implements CommandExecutor, TabCompleter {
     private final Main plugin;
@@ -22,10 +23,16 @@ public class CreateKitCommand implements CommandExecutor, TabCompleter {
     public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
         if (sender instanceof Player player) {
             if (args.length == 1) {
-                plugin.getConfig().set("default.kits." + args[0], player.getInventory().getContents());
+                String base64 = Kits.itemStackArrayToBase64(player.getInventory().getContents());
-                plugin.saveConfig();
+
-                plugin.reloadConfig();
+                Map<String, Object> data = new HashMap<>();
-                player.sendMessage("§aKit saved as " + args[0]);
+                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;

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

@@ -1,6 +1,7 @@
-package lnmpro.Commands;
+package hu.jgj52.pvpcore.Commands;
 
-import lnmpro.Main;
+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;
@@ -11,8 +12,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
-import java.util.Map;
+import java.util.Objects;
-import java.util.UUID;
+import java.util.concurrent.ExecutionException;
 
 public class DenyDuelCommand implements CommandExecutor, TabCompleter {
     private final Main plugin;
@@ -29,8 +30,14 @@ public class DenyDuelCommand implements CommandExecutor, TabCompleter {
                 return true;
             }
 
-            Map<UUID, Main.DuelRequestData> requests = plugin.duelRequests.get(player.getUniqueId());
+            Database.QueryResult reqResult = null;
-            if (requests == 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;
             }
@@ -40,18 +47,7 @@ public class DenyDuelCommand implements CommandExecutor, TabCompleter {
                 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();
-            if (requests.remove(enemy.getUniqueId()) != null) {
-                if (requests.isEmpty()) {
-                    plugin.duelRequests.remove(player.getUniqueId());
-                }
-                player.sendMessage("§aPárbajkérelem elutasítva.");
-                enemy.sendMessage("§c" + player.getName() + " elutasította a párbajkérelmedet.");
-            } else {
-                player.sendMessage("§cNincs párbajkérelmed ettől a játékostól.");
-            }
-        } else {
-            sender.sendMessage("nem vagy player nem fog sikerulni");
         }
         return true;
     }

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

@@ -1,6 +1,7 @@
-package lnmpro.Commands;
+package hu.jgj52.pvpcore.Commands;
 
-import lnmpro.Main;
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.Database;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.command.Command;
@@ -22,8 +23,11 @@ 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;
@@ -54,7 +58,14 @@ public class DuelCommand implements CommandExecutor, TabCompleter {
                 return true;
             }
 
-            if (target.hasMetadata("DueledBy") && target.getMetadata("DueledBy").get(0).asString().equals(player.getUniqueId().toString())) {
+            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;
             }
@@ -141,11 +152,16 @@ public class DuelCommand implements CommandExecutor, TabCompleter {
             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, kekuveg);
+            gui.setItem(4, ft);
             gui.setItem(5, kekuveg);
             gui.setItem(6, kekuveg);
             gui.setItem(7, kekuveg);
@@ -179,10 +195,11 @@ public class DuelCommand implements CommandExecutor, TabCompleter {
             gui.setItem(35, kekuveg);
 
             player.openInventory(gui);
-            player.setMetadata("DuelRequest", new FixedMetadataValue(plugin, target.getUniqueId().toString()));
+            Map<String, Object> data = new HashMap<>();
-
+            data.put("player", player.getUniqueId());
-        } else {
+            data.put("enemy", target.getUniqueId());
-            sender.sendMessage("szia nem vagy player ez nem vicces");
+            data.put("timestamp", System.currentTimeMillis() + 60000);
+            plugin.db.from("pvpcore_duel_requests").insert(data);
         }
         return true;
     }

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

@@ -1,6 +1,6 @@
-package lnmpro.Commands;
+package hu.jgj52.pvpcore.Commands;
 
-import lnmpro.Main;
+import hu.jgj52.pvpcore.Main;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
@@ -25,7 +25,7 @@ public class LeaveCommand implements CommandExecutor, TabCompleter {
                 player.setHealth(0);
             }
             if (player.getMetadata("IsSpectating").get(0).asBoolean()) {
-                plugin.removePlayerFromDuel(player);
+                plugin.tpToSpawn(player);
             }
         }
         return true;

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

@@ -1,7 +1,7 @@
-package lnmpro.Commands;
+package hu.jgj52.pvpcore.Commands;
 
-import lnmpro.Main;
+import hu.jgj52.pvpcore.Main;
-import lnmpro.Utils.WorldReset;
+import hu.jgj52.pvpcore.Utils.WorldReset;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;

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

@@ -1,6 +1,6 @@
-package lnmpro.Commands;
+package hu.jgj52.pvpcore.Commands;
 
-import lnmpro.Main;
+import hu.jgj52.pvpcore.Main;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
 import org.bukkit.command.Command;

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

@@ -0,0 +1,229 @@
+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() && (row.get("ft") == row.get("player_points") || row.get("ft") == row.get("enemy_points"))) {
+            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(1);
+                    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() && row.get("ft") != row.get("player_points") && row.get("ft") != row.get("enemy_points")) {
+            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);
+            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 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);
+
+            player.setMetadata("Frozen", new FixedMetadataValue(plugin, true));
+            enemy.setMetadata("Frozen", new FixedMetadataValue(plugin, true));
+
+            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);
+                        player.removeMetadata("Frozen", plugin);
+                        enemy.removeMetadata("Frozen", plugin);
+                        cancel();
+                    }
+                }
+            }.runTaskTimer(plugin, 0L, 20L);
+        } else {
+            e.setCancelled(true);
+            plugin.tpToSpawn(player);
+        }
+    }
+}

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

@@ -1,6 +1,7 @@
-package lnmpro.Listeners;
+package hu.jgj52.pvpcore.Listeners;
 
-import lnmpro.Main;
+import hu.jgj52.pvpcore.Main;
+import hu.jgj52.pvpcore.Utils.Database;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.Material;
@@ -9,15 +10,18 @@ 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 org.bukkit.metadata.FixedMetadataValue;
 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.entity.Player;
+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;
@@ -36,37 +40,49 @@ public class DuelRequestListener implements Listener {
     }
 
     @EventHandler
-    public void onDuelRequest(InventoryClickEvent e) {
+    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;
 
-        if (e.getClick() != ClickType.LEFT) 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)
+        if (clickedItem.getType() == Material.RED_STAINED_GLASS_PANE || clickedItem.getType() == Material.BLUE_STAINED_GLASS_PANE) return;
-            return;
 
-        if (player.hasMetadata("DuelRequest")) {
+        if (clickedItem.getType() == Material.PAPER) {
-            e.setCancelled(true);
+            int count = clickedItem.getAmount();
-
+            if (e.getClick() == ClickType.LEFT) {
-            UUID targetUUID = UUID.fromString(player.getMetadata("DuelRequest").get(0).asString());
+                count++;
-            Player target = Bukkit.getPlayer(targetUUID);
+            } else if (e.getClick() == ClickType.RIGHT) {
-
+                count--;
-            if (target == null) {
+            }
-                player.sendMessage("§cA meghívott játékos nincs jelen a szerveren.");
+            clickedItem.setAmount(count);
-                player.removeMetadata("DuelRequest", plugin);
             return;
         }
 
-            player.removeMetadata("DuelRequest", plugin);
+        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());
-            plugin.duelRequests.computeIfAbsent(target.getUniqueId(), k -> new java.util.HashMap<>())
-                    .put(player.getUniqueId(), new Main.DuelRequestData(System.currentTimeMillis(), gamemode));
 
+            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()));
@@ -85,7 +101,6 @@ public class DuelRequestListener implements Listener {
                             .append("§7Ellenfél: §e" + player.getName() + "\n")
                             .append("§7Opciók:\n")
                             .append("§8- §7Kör: §e1\n")
-                            .append("§8- §7Megfigyelők: §aBEKAPCSOLVA\n")
                             .create()));
 
             TextComponent fullMessage = new TextComponent();

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

@@ -1,4 +1,4 @@
-package lnmpro.Listeners;
+package hu.jgj52.pvpcore.Listeners;
 
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;

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,121 @@
+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<>();
+        if (result.isEmpty()) {
+            data.put("uuid", event.getPlayer().getUniqueId());
+            data.put("admin", event.getPlayer().hasPermission("pvpcore.admin"));
+            plugin.db.from("pvpcore_players").insert(data);
+        } else {
+            data.put("admin", event.getPlayer().hasPermission("pvpcore.admin"));
+            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();
+        for (String key : plugin.metadatas) {
+            for (MetadataValue value : player.getMetadata(key)) {
+                if (value.getOwningPlugin() == plugin) {
+                    player.removeMetadata(key, plugin);
+                    break;
+                }
+            }
+        }
+        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());
+            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

@@ -1,36 +1,29 @@
-package lnmpro;
+package hu.jgj52.pvpcore;
 
-import lnmpro.Utils.WorldReset;
+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.event.Listener;
 import org.bukkit.metadata.MetadataValue;
 import org.bukkit.plugin.java.JavaPlugin;
-import lnmpro.Commands.*;
-import lnmpro.Listeners.*;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 import org.bukkit.scheduler.BukkitRunnable;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.HashMap;
+import java.util.concurrent.ExecutionException;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
 
 public final class Main extends JavaPlugin {
 
-    public final String[] metadatas = {"DuelingWith", "ArenaLoc", "Frozen", "DuelRequest", "DueledBy", "DueledWithGamemode", "IsSpectating"};
+    public Database db = new Database("188.245.120.192", 24454, "wolfpvp", "wolfpvp", "eVE9*!9qtj08jXuxe$#$a08jNxVdMTbt");
 
-    private static Main instance;
+    public final String[] metadatas = {"Frozen"};
 
-    public record DuelRequestData(long timestamp, String gamemode) {}
+    public void tpToSpawn(Player player) {
-    public Map<UUID, Map<UUID, DuelRequestData>> duelRequests = new HashMap<>();
+        Location spawn = new Location(Bukkit.getWorld("world"), 0.5, 3, 0.5, 0, 0);
-
-    public void removePlayerFromDuel(Player player) {
-        Location spawn = new Location(Bukkit.getWorld("world"), 0, 3, 0, 0, 0);
         for (PotionEffect potionEffect : player.getActivePotionEffects()) {
             player.removePotionEffect(potionEffect.getType());
         }
@@ -69,45 +62,60 @@ public final class Main extends JavaPlugin {
         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 FreezeListener(), this);
-        getServer().getPluginManager().registerEvents(new PlayerLeaveListener(this), this);
+        getServer().getPluginManager().registerEvents(new PlayerListener(this), this);
         getServer().getPluginManager().registerEvents(new SpectatorListener(this), this);
 
-        new BukkitRunnable() {
-            @Override
-            public void run() {
-                long now = System.currentTimeMillis();
-                duelRequests.values().forEach(requests -> requests.entrySet().removeIf(entry -> (now - entry.getValue().timestamp()) > 60000));
-                duelRequests.entrySet().removeIf(entry -> entry.getValue().isEmpty());
-            }
-        }.runTaskTimer(this, 0L, 20L * 60); // Run every minute
-
         WorldReset worldReset = new WorldReset(this);
         worldReset.recreateArenaWorld();
 
-        instance = this;
+        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() {
-        for (Player player : Bukkit.getOnlinePlayers()) {
+        //hi
-            for (String key : metadatas) {
-                for (MetadataValue value : player.getMetadata(key)) {
-                    if (value.getOwningPlugin() == this) {
-                        player.removeMetadata(key, this);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    public static Main getInstance() {
-        return instance;
     }
 
     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

@@ -1,4 +1,4 @@
-package lnmpro.Utils;
+package hu.jgj52.pvpcore.Utils;
 
 import com.sk89q.worldedit.EditSession;
 import com.sk89q.worldedit.WorldEdit;
@@ -9,24 +9,17 @@ 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.history.change.BlockChange;
 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 lnmpro.Main;
+import hu.jgj52.pvpcore.Main;
-import org.bukkit.Bukkit;
 import org.bukkit.Location;
-import org.bukkit.Material;
 import org.bukkit.World;
-import org.bukkit.scheduler.BukkitRunnable;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Consumer;
 
 public class SchematicManager {
     private final Main plugin;

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

@@ -1,4 +1,4 @@
-package lnmpro.Utils;
+package hu.jgj52.pvpcore.Utils;
 
 import org.bukkit.*;
 import org.bukkit.metadata.MetadataValue;

src/main/java/lnmpro/Commands/EditKitCommand.java

@@ -1,106 +0,0 @@
-package lnmpro.Commands;
-
-import lnmpro.Main;
-import lnmpro.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;
-
-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.hasPermission("insaneduels.editkit")) {
-            if (sender instanceof Player player) {
-                if (args.length > 0) {
-                    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));
-
-                    player.openInventory(gui);
-                }
-            }
-        }
-        return true;
-    }
-
-    @Override
-    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
-        if (args.length == 1) {
-            ConfigurationSection kitsSection = plugin.getConfig().getConfigurationSection("default.kits");
-            if (kitsSection != null) {
-                String current = args[0].toLowerCase();
-
-                List<String> matches = kitsSection.getKeys(false).stream()
-                        .filter(kit -> kit.toLowerCase().startsWith(current))
-                        .toList();
-
-                return matches.isEmpty() ? List.of() : List.of(matches.toArray(new String[0]));
-            }
-        }
-        return List.of();
-    }
-}

src/main/java/lnmpro/Listeners/DuelEndListener.java

@@ -1,91 +0,0 @@
-package lnmpro.Listeners;
-
-import lnmpro.Main;
-import lnmpro.Utils.SchematicManager;
-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.UUID;
-import net.kyori.adventure.text.Component;
-import net.kyori.adventure.title.Title;
-import org.bukkit.inventory.meta.FireworkMeta;
-
-public class DuelEndListener implements Listener {
-    private final Main plugin;
-
-    public DuelEndListener(Main plugin) {
-        this.plugin = plugin;
-    }
-
-    @EventHandler
-    public void onDuelEnd(PlayerDeathEvent e) {
-        Player player = e.getPlayer();
-        if (player.hasMetadata("DuelingWith")) {
-            SchematicManager schematic = new SchematicManager(plugin);
-            UUID targetUUID = UUID.fromString(player.getMetadata("DuelingWith").get(0).asString());
-            Player enemy = Bukkit.getPlayer(targetUUID);
-            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(1);
-                    firework.setFireworkMeta(meta);
-                }, delay);
-            }
-
-            player.showTitle(loserTitle);
-            enemy.showTitle(winnerTitle);
-
-            Bukkit.getScheduler().runTaskLater(plugin, () -> {
-                try {
-                    plugin.removePlayerFromDuel(player);
-                    plugin.removePlayerFromDuel(enemy);
-                } catch (Exception exception) {
-                    exception.printStackTrace();
-                }
-            }, 60L);
-
-            player.removeMetadata("DuelingWith", plugin);
-            enemy.removeMetadata("DuelingWith", plugin);
-            player.removeMetadata("ArenaLoc", plugin);
-            enemy.removeMetadata("ArenaLoc", plugin);
-            player.removeMetadata("DueledWithGamemode", plugin);
-            enemy.removeMetadata("DueledWithGamemode", plugin);
-        }
-    }
-}

src/main/java/lnmpro/Listeners/KitListener.java

@@ -1,96 +0,0 @@
-package lnmpro.Listeners;
-
-import lnmpro.Main;
-import net.kyori.adventure.text.Component;
-import org.bukkit.Material;
-import org.bukkit.enchantments.Enchantment;
-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.Inventory;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-public class KitListener implements Listener {
-    private final Main plugin;
-
-    public KitListener(Main plugin) {
-        this.plugin = plugin;
-    }
-
-    @EventHandler
-    public void onInventoryClick(InventoryClickEvent event) {
-        if (!(event.getWhoClicked() instanceof  Player player)) return;
-        Inventory gui = event.getInventory();
-        ItemStack[] inv = player.getInventory().getContents();
-
-        if (event.getClickedInventory() == event.getView().getTopInventory() && event.getView().title().equals(Component.text("Kit Editor"))) {
-            event.setCancelled(true);
-            if ((0 <= event.getSlot() && event.getSlot() <= 2) || (9 <= event.getSlot() && event.getSlot() <= 11) || (18 <= event.getSlot() && event.getSlot() <= 20)) {
-                String gamemode = event.getClickedInventory().getItem(13).getItemMeta().getDisplayName().split(" ")[2];
-                ItemStack[] kit = ((List<ItemStack>) plugin.getConfig().get("default.kits." + gamemode)).toArray(new ItemStack[0]);
-                Map<String, Integer> kitTotals = new HashMap<>();
-                for (ItemStack kitItem : kit) {
-                    if (kitItem == null) continue;
-                    String key = kitItem.getType().toString() + kitItem.getItemMeta().toString();
-                    kitTotals.put(key, kitTotals.getOrDefault(key, 0) + kitItem.getAmount());
-                }
-
-                Map<String, Integer> invTotals = new HashMap<>();
-                for (ItemStack invItem : inv) {
-                    if (invItem == null) continue;
-                    String key = invItem.getType().toString() + invItem.getItemMeta().toString();
-                    invTotals.put(key, invTotals.getOrDefault(key, 0) + invItem.getAmount());
-                }
-
-                boolean valid = true;
-                for (Map.Entry<String, Integer> entry : invTotals.entrySet()) {
-                    String key = entry.getKey();
-                    int invAmount = entry.getValue();
-                    int kitAmount = kitTotals.getOrDefault(key, 0);
-
-                    if (invAmount > kitAmount) {
-                        valid = false;
-                        break;
-                    }
-                }
-
-                for (String key : invTotals.keySet()) {
-                    if (!kitTotals.containsKey(key)) {
-                        valid = false;
-                        break;
-                    }
-                }
-
-                if (valid) {
-                    plugin.getConfig().set("kits." + player.getUniqueId() + "." + gamemode, inv);
-                    plugin.saveConfig();
-                    plugin.reloadConfig();
-                    player.closeInventory();
-                    player.sendMessage("§aA kit el lett mentve.");
-                } else {
-                    player.closeInventory();
-                    player.sendMessage("§cA kited nem került mentésre.");
-                }
-            } else if ((6 <= event.getSlot() && event.getSlot() <= 8) || (15 <= event.getSlot() && event.getSlot() <= 17) || (24 <= event.getSlot() && event.getSlot() <= 26)) {
-                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/lnmpro/Listeners/PlayerLeaveListener.java

@@ -1,31 +0,0 @@
-package lnmpro.Listeners;
-
-import lnmpro.Main;
-import org.bukkit.entity.Player;
-import org.bukkit.event.Listener;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.player.PlayerQuitEvent;
-import org.bukkit.metadata.MetadataValue;
-
-public class PlayerLeaveListener implements Listener {
-    private final Main plugin;
-
-    public PlayerLeaveListener(Main plugin) {
-        this.plugin = plugin;
-    }
-    @EventHandler
-    public void onLeave(PlayerQuitEvent e) {
-        Player player = e.getPlayer();
-        for (String key : plugin.metadatas) {
-            for (MetadataValue value : player.getMetadata(key)) {
-                if (value.getOwningPlugin() == plugin) {
-                    player.removeMetadata(key, plugin);
-                    break;
-                }
-            }
-        }
-        if (player.hasMetadata("DuelingWith")) {
-            player.setHealth(0);
-        }
-    }
-}

src/main/java/lnmpro/Utils/Kits.java

@@ -1,39 +0,0 @@
-package lnmpro.Utils;
-
-import lnmpro.Main;
-import org.bukkit.Material;
-import org.bukkit.block.ShulkerBox;
-import org.bukkit.enchantments.Enchantment;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.PlayerInventory;
-import org.bukkit.inventory.meta.BlockStateMeta;
-import org.bukkit.inventory.meta.PotionMeta;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collections;
-import java.util.List;
-
-public class Kits {
-
-    private final Main plugin;
-
-    public Kits(Main plugin) {
-        this.plugin = plugin;
-    }
-
-    public ItemStack[] getKit(String gamemode, Player player) {
-        if (plugin.getConfig().get("kits." + player.getUniqueId() + "." + gamemode) != null) {
-            ItemStack[] kit = ((List<ItemStack>) plugin.getConfig().get("kits." + player.getUniqueId() + "." + gamemode)).toArray(new ItemStack[0]);
-
-            return kit;
-        } else {
-            ItemStack[] kit = ((List<ItemStack>) plugin.getConfig().get("default.kits." + gamemode)).toArray(new ItemStack[0]);
-
-            return kit;
-        }
-    }
-}

src/main/resources/config.yml

@@ -1,3 +0,0 @@
-kits: {}
-default:
-  kits: {}

src/main/resources/plugin.yml

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

target/classes/config.yml

@@ -1,3 +0,0 @@
-kits: {}
-default:
-  kits: {}

target/classes/plugin.yml

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

target/maven-archiver/pom.properties

@@ -1,3 +1,3 @@
-artifactId=InsaneDuels
+artifactId=PvPCore
-groupId=lnmpro
+groupId=hu.jgj52.pvpcore
-version=1.0-SNAPSHOT
+version=1.0

target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst

@@ -1,15 +1,29 @@
-lnmpro/Listeners/FreezeListener.class
+hu/jgj52/pvpcore/Utils/Database.class
-lnmpro/Main$DuelRequestData.class
+hu/jgj52/pvpcore/Listeners/PlayerListener.class
-lnmpro/Listeners/PlayerLeaveListener.class
+hu/jgj52/pvpcore/Commands/ConnectCommand.class
-lnmpro/Commands/AcceptDuelCommand$1.class
+hu/jgj52/pvpcore/Commands/ResetArenasCommand.class
-lnmpro/Commands/ResetArenasCommand.class
+hu/jgj52/pvpcore/Main.class
-lnmpro/Commands/DuelCommand.class
+hu/jgj52/pvpcore/Commands/DenyDuelCommand.class
-lnmpro/Listeners/DuelEndListener.class
+hu/jgj52/pvpcore/Listeners/DuelRequestListener.class
-lnmpro/Commands/SpectateCommand.class
+hu/jgj52/pvpcore/Commands/DuelCommand.class
-lnmpro/Utils/SchematicManager.class
+hu/jgj52/pvpcore/Utils/Database$QueryBuilder.class
-lnmpro/Utils/WorldReset.class
+hu/jgj52/pvpcore/Utils/Kits.class
-lnmpro/Listeners/SpectatorListener.class
+hu/jgj52/pvpcore/Listeners/DuelEndListener.class
-lnmpro/Commands/CreateKitCommand.class
+hu/jgj52/pvpcore/Listeners/DuelEndListener$1.class
-lnmpro/Commands/LeaveCommand.class
+hu/jgj52/pvpcore/Utils/WorldReset.class
-lnmpro/Main$1.class
+hu/jgj52/pvpcore/Commands/AcceptDuelCommand.class
-lnmpro/Commands/EditKitCommand.class
+hu/jgj52/pvpcore/Commands/EditKitCommand.class
+hu/jgj52/pvpcore/Utils/Kits$1.class
+hu/jgj52/pvpcore/Utils/Database$QueryResult.class
+hu/jgj52/pvpcore/Utils/Database$WhereClause.class
+hu/jgj52/pvpcore/Utils/Database$FilterClause.class
+hu/jgj52/pvpcore/Listeners/SpectatorListener.class
+hu/jgj52/pvpcore/Listeners/FreezeListener.class
+hu/jgj52/pvpcore/Commands/CreateKitCommand.class
+hu/jgj52/pvpcore/Listeners/KitListener$1.class
+hu/jgj52/pvpcore/Listeners/KitListener.class
+hu/jgj52/pvpcore/Commands/AcceptDuelCommand$1.class
+hu/jgj52/pvpcore/Commands/LeaveCommand.class
+hu/jgj52/pvpcore/Commands/SpectateCommand.class
+hu/jgj52/pvpcore/Utils/SchematicManager.class
+hu/jgj52/pvpcore/Main$1.class

target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst

@@ -1,18 +1,20 @@
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Commands/AcceptDuelCommand.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Commands/AcceptDuelCommand.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Commands/CreateKitCommand.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Commands/ConnectCommand.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Commands/DenyDuelCommand.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Commands/CreateKitCommand.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Commands/DuelCommand.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Commands/DenyDuelCommand.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Commands/EditKitCommand.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Commands/DuelCommand.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Commands/LeaveCommand.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Commands/EditKitCommand.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Commands/ResetArenasCommand.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Commands/LeaveCommand.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Commands/SpectateCommand.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Commands/ResetArenasCommand.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Listeners/DuelEndListener.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Commands/SpectateCommand.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Listeners/DuelRequestListener.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Listeners/DuelEndListener.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Listeners/FreezeListener.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Listeners/DuelRequestListener.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Listeners/KitListener.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Listeners/FreezeListener.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Listeners/PlayerLeaveListener.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Listeners/KitListener.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Listeners/SpectatorListener.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Listeners/PlayerListener.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Main.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Listeners/SpectatorListener.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Utils/Kits.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Main.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Utils/SchematicManager.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Utils/Database.java
-/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/lnmpro/Utils/WorldReset.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Utils/Kits.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Utils/SchematicManager.java
+/home/jgj52/IdeaProjects/InsaneDuels/src/main/java/hu/jgj52/pvpcore/Utils/WorldReset.java