Merge remote-tracking branch 'origin/dev' into dev

fix databáze

.gitignore

@@ -1,6 +1,7 @@
+src/main/resources/config.yml
 # User-specific stuff
 .idea/
-
+config.yml
 *.iml
 *.ipr
 *.iws
@@ -111,3 +112,5 @@ buildNumber.properties
 
 # Common working directory
 run/
+!/src/main/java/xyz/mineconomia/mineconomiacore/commands/bed.java
+!/src/main/resources/config.yml

pom.xml

@@ -5,20 +5,21 @@
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>xyz.mineconomia</groupId>
-    <artifactId>MineconomiaCOre</artifactId>
+    <artifactId>MineconomiaCore</artifactId>
     <version>1.0-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <name>MineconomiaCore</name>
 
     <properties>
-        <java.version>1.8</java.version>
+        <java.version>1.17</java.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 
     <build>
         <plugins>
             <plugin>
+
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.8.1</version>
@@ -39,6 +40,7 @@
                         </goals>
                         <configuration>
                             <createDependencyReducedPom>false</createDependencyReducedPom>
+
                         </configuration>
                     </execution>
                 </executions>
@@ -61,20 +63,44 @@
             <id>sonatype</id>
             <url>https://oss.sonatype.org/content/groups/public/</url>
         </repository>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </repository>
     </repositories>
 
     <dependencies>
         <dependency>
             <groupId>org.spigotmc</groupId>
             <artifactId>spigot-api</artifactId>
-            <version>1.20-R0.1-SNAPSHOT</version>
+            <version>1.18.2-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency> 
+            <groupId>com.github.MilkBowl</groupId>
+            <artifactId>VaultAPI</artifactId>
+            <version>1.7</version>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>com.arangodb</groupId>
+            <artifactId>arangodb-java-driver</artifactId>
+            <version>6.13.0</version>
+        </dependency>
+
+        <!-- https://mvnrepository.com/artifact/org.hibernate.orm/hibernate-core -->
+
+
         <dependency>
             <groupId>org.jetbrains</groupId>
             <artifactId>annotations</artifactId>
             <version>20.1.0</version>
             <scope>compile</scope>
         </dependency>
+        <dependency>
+            <groupId>xyz.upperlevel.spigot.book</groupId>
+            <artifactId>spigot-book-api</artifactId>
+            <version>1.6</version>
+        </dependency>
     </dependencies>
 </project>

src/main/java/xyz/mineconomia/mineconomiacore/CustomItems/ItemManager.java

@@ -0,0 +1,51 @@
+package xyz.mineconomia.mineconomiacore.CustomItems;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.ShapelessRecipe;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataType;
+import xyz.mineconomia.mineconomiacore.PDC;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ItemManager {
+
+    public static ItemStack Ruler;
+
+    public static void init() {
+            createRuler();
+
+    }
+    private static void createRuler() {
+
+        //Item Info
+        ItemStack item = new ItemStack(Material.STICK, 1);
+        ItemMeta meta = item.getItemMeta();
+        assert meta != null;
+        meta.setDisplayName("§e§lPravítko");
+        List<String> lore = new ArrayList<>();
+        lore.add("");
+        lore.add("§7Tento item je speciální.");
+        lore.add("§7Umožňuje vytvářet obchody a definovat pozemky");
+        lore.add(ChatColor.AQUA + "Více info na naší wiki");
+        meta.setLore(lore);
+        meta.addEnchant(Enchantment.LUCK, 1, false);
+        meta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
+        PDC.WriteItemMetaPDC(meta, "special", PersistentDataType.INTEGER,1);
+        item.setItemMeta(meta);
+        Ruler = item;
+
+        //Shapeless Recipe
+        ShapelessRecipe sir = new ShapelessRecipe(NamespacedKey.minecraft("ruler_shapeless"), item);
+        sir.addIngredient(1, Material.STICK);
+        Bukkit.getServer().addRecipe(sir);
+
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/MineconomiaCore.java

@@ -1,19 +1,39 @@
 package xyz.mineconomia.mineconomiacore;
 
+import net.milkbowl.vault.economy.Economy;
 import org.bukkit.Bukkit;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.RegisteredServiceProvider;
 import org.bukkit.plugin.java.JavaPlugin;
-import xyz.mineconomia.mineconomiacore.commands.mcore;
+import xyz.mineconomia.mineconomiacore.CustomItems.ItemManager;
+import xyz.mineconomia.mineconomiacore.commands.*;
+import xyz.mineconomia.mineconomiacore.events.*;
+import xyz.mineconomia.mineconomiacore.handlers.FHBHandler;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
 import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 public final class MineconomiaCore extends JavaPlugin {
+    public static Logger logger = Bukkit.getLogger();
+    private static Economy econ = null;
 
     @Override
     public void onEnable() {
-        // Plugin startup logic
 
+        // Plugin startup logic
+        saveDefaultConfig();
         MineconomiaCore plugin= getPlugin(MineconomiaCore.class);
+        if (!setupEconomy()) {
+            logger.info("No Vault economy! Stopping");
+            getServer().getPluginManager().disablePlugin(this);
+            return;
+        }
+
+        //Tohle třeba změnit později - jakub
         Logger logger= plugin.getLogger();
             logger.info(" ");
             logger.info("      ╔═══════════════════╗");
@@ -26,11 +46,67 @@ public final class MineconomiaCore extends JavaPlugin {
             logger.info("║                               ║");
             logger.info("╚═══════════════════════════════╝");
             logger.info("");
+        PluginManager pm = getServer().getPluginManager();
+        pm.registerEvents(new FHBHandler(), this);
+        pm.registerEvents(new playerAccount(), this);
+        pm.registerEvents(new specialEvents(), this);
+        pm.registerEvents(new shopInteract(), this);
+        pm.registerEvents(new shopGuiInteract(), this);
+        pm.registerEvents(new sellClose(), this);
+        pm.registerEvents(new spawnRadiusMessage(), this);
+        pm.registerEvents(new toggleFrame(), this);
+        pm.registerEvents(new signComplete(), this);
+
         Objects.requireNonNull(plugin.getCommand("mcore")).setExecutor(new mcore());
+        Objects.requireNonNull(getCommand("pomoc")).setExecutor(new BookCommand());
+        Objects.requireNonNull(getCommand("tpw")).setExecutor(new tpw());
+        Objects.requireNonNull(getCommand("fhb")).setExecutor(new funHarvestBall());
+        Objects.requireNonNull(getCommand("shop")).setExecutor(new shop());
+        Objects.requireNonNull(getCommand("sample")).setExecutor(new sample());
+        Objects.requireNonNull(getCommand("gamble")).setExecutor(new gamble());
+        Objects.requireNonNull(getCommand("sell")).setExecutor(new sell());
+        Objects.requireNonNull(getCommand("spawn")).setExecutor(new spawn());
+        Objects.requireNonNull(getCommand("bed")).setExecutor(new bed());
+        Objects.requireNonNull(getCommand("setSign")).setExecutor(new setSign());
+        Objects.requireNonNull(getCommand("mcore")).setTabCompleter(new mcore());
+        Objects.requireNonNull(getCommand("editSign")).setExecutor(new editSign());
+
+        //CustomItems
+        ItemManager.init();
     }
 
     @Override
     public void onDisable() {
         // Plugin shutdown logic
+        saveConfig();
+
+    }
+    private boolean setupEconomy() {
+        if (getServer().getPluginManager().getPlugin("Vault") == null) {
+            return false;
+        }
+        RegisteredServiceProvider<Economy> rsp = getServer().getServicesManager().getRegistration(Economy.class);
+        if (rsp == null) {
+            return false;
+        }
+        econ = rsp.getProvider();
+        return true;
+    }
+
+    public static Economy getEconomy() {
+        return econ;
+    }
+    public static List<String> getArgs(String input) {
+        List<String> result = new ArrayList<>();
+        Pattern pattern = Pattern.compile("\"([^\"]*)\"|([^\\s]+)");
+        Matcher matcher = pattern.matcher(input);
+        while (matcher.find()) {
+            String match = matcher.group(1); // Check if the first group (quoted string) matched
+            if (match == null) {
+                match = matcher.group(2); // If not, use the second group (unquoted string)
+            }
+            result.add(match);
+        }
+        return result;
     }
 }

src/main/java/xyz/mineconomia/mineconomiacore/PDC.java

@@ -0,0 +1,58 @@
+package xyz.mineconomia.mineconomiacore;
+
+import org.bukkit.NamespacedKey;
+import org.bukkit.block.TileState;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+
+
+//Used by other classes for easy manipulation with persistentDataContainer
+public class PDC {
+
+
+
+
+        public static void WritePlayerPDC(Player player, String key, PersistentDataType type, Object value){
+            NamespacedKey nKey = new NamespacedKey(MineconomiaCore.getPlugin(MineconomiaCore.class), key);
+            PersistentDataContainer pdc = player.getPersistentDataContainer();
+            pdc.set(nKey, type, value);
+
+        }
+        public static Object GetPlayerPDC(Player player, String key, PersistentDataType type){
+            NamespacedKey nKey = new NamespacedKey(MineconomiaCore.getPlugin(MineconomiaCore.class), key);
+            PersistentDataContainer pdc = player.getPersistentDataContainer();
+            return pdc.get(nKey, type);
+        }
+        public static void DeletePlayerPDC(Player player, String key){
+            NamespacedKey nKey = new NamespacedKey(MineconomiaCore.getPlugin(MineconomiaCore.class), key);
+            PersistentDataContainer pdc = player.getPersistentDataContainer();
+            pdc.remove(nKey);
+
+        }
+        public static void WriteItemMetaPDC(ItemMeta itemMeta, String key, PersistentDataType type, Object value){
+            NamespacedKey nKey = new NamespacedKey(MineconomiaCore.getPlugin(MineconomiaCore.class), key);
+            PersistentDataContainer pdc = itemMeta.getPersistentDataContainer();
+            pdc.set(nKey, type, value);
+
+        }
+        public static Object GetItemMetaPDC(ItemMeta itemMeta, String key, PersistentDataType type){
+            NamespacedKey nKey = new NamespacedKey(MineconomiaCore.getPlugin(MineconomiaCore.class), key);
+            PersistentDataContainer pdc = itemMeta.getPersistentDataContainer();
+            return pdc.get(nKey, type);
+        }
+        public static void WriteTileStatePDC(TileState tileState, String key, PersistentDataType type, Object value){
+            NamespacedKey nKey = new NamespacedKey(MineconomiaCore.getPlugin(MineconomiaCore.class), key);
+            PersistentDataContainer pdc = tileState.getPersistentDataContainer();
+            pdc.set(nKey, type, value);
+
+        }
+    public static Object GetTileStatePDC(TileState tileState, String key, PersistentDataType type){
+        NamespacedKey nKey = new NamespacedKey(MineconomiaCore.getPlugin(MineconomiaCore.class), key);
+        PersistentDataContainer pdc = tileState.getPersistentDataContainer();
+        return pdc.get(nKey, type);
+    }
+
+
+}

src/main/java/xyz/mineconomia/mineconomiacore/commands/BookCommand.java

@@ -0,0 +1,67 @@
+package xyz.mineconomia.mineconomiacore.commands;
+
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import xyz.upperlevel.spigot.book.BookUtil;
+
+
+
+public class BookCommand implements CommandExecutor {
+
+    //Experimentální. Bude se měnit
+    @Override
+    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+        if (sender instanceof Player) {
+            Player player = (Player) sender;
+
+            //Create a Book
+            ItemStack book = BookUtil.writtenBook()
+                    .author("Temný řád serveru Mineconomia")
+                    .title("Příručka nejen pro začátečníky")
+                    .pages(
+
+                            new BookUtil.PageBuilder()
+                                    .newLine()
+                                    .add(new TextComponent(ChatColor.GOLD + String.valueOf(ChatColor.BOLD)+ "MINECONOMIA"))
+                                    .newLine()
+                                    .add(ChatColor.ITALIC + "" + ChatColor.GRAY + "Economy server")
+                                    .newLine()
+                                    .newLine()
+                                    .add(ChatColor.GOLD + "■■■■■■■■■■■■■■■■■■■")
+                                    .newLine()
+                                    .add(ChatColor.GRAY + "Užitečná příručka nejen pro nové hráče")
+                                    .newLine()
+                                    .add(ChatColor.GOLD + "■■■■■■■■■■■■■■■■■■■")
+                                    .newLine()
+                                    .newLine()
+                                    .newLine()
+                                    .newLine()
+                                    .add(ChatColor.GOLD + String.valueOf(ChatColor.BOLD) + "TIP: " + ChatColor.BLACK + "pro rychlou navigaci klikej na položky v obsahu")
+                                    .build(),
+                            new BookUtil.PageBuilder()
+                                    .add(ChatColor.GOLD + String.valueOf(ChatColor.BOLD) +"OBSAH (1/2)")
+                                    .newLine().newLine().newLine()
+                                    .add(ChatColor.GRAY + "- Kde vzít peníze?")
+                                    .newLine().newLine()
+                                    .add(ChatColor.GRAY + "- Tvůj první pozemek")
+                                    .newLine().newLine()
+                                    .add(ChatColor.GRAY + "- Co je to pravítko")
+                                    .newLine().newLine()
+                                    .add(ChatColor.GRAY + "- Tvůj první obchod")
+                                    .newLine().newLine()
+                                    .add(ChatColor.GRAY + "- Využij pozemek")
+
+                                    .build()
+                    )
+                    .build();
+
+            BookUtil.openPlayer(player, book);
+        }
+        return false;
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/commands/bed.java

@@ -0,0 +1,21 @@
+package xyz.mineconomia.mineconomiacore.commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class bed implements CommandExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) {
+        Player player = (Player) commandSender;
+        if(player.getBedSpawnLocation() == null){
+            player.sendMessage(ChatColor.RED + "Nemáš postel");
+            return true;
+        }
+        player.teleport(player.getBedSpawnLocation());
+        return true;
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/commands/editSign.java

@@ -0,0 +1,47 @@
+package xyz.mineconomia.mineconomiacore.commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.block.Sign;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.mineconomia.mineconomiacore.handlers.SignHandler;
+
+import java.util.List;
+
+import static xyz.mineconomia.mineconomiacore.MineconomiaCore.getArgs;
+
+public class editSign implements TabExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        StringBuilder argsString = new StringBuilder();
+        for (String ss : args) {
+            argsString.append(ChatColor.translateAlternateColorCodes('&', ss)).append(" ");
+        }
+        List<String> pArgs = getArgs(argsString.toString());
+        if (pArgs.size() != 2){
+            commandSender.sendMessage(ChatColor.RED + "špatný počet argumentů");
+            return false;
+        }
+        Player player = (Player) commandSender;
+
+        if (!(player.getTargetBlock(null, 5).getState() instanceof Sign sign)){
+
+            commandSender.sendMessage(ChatColor.RED + "musíš se dívat na cedulku");
+            return false;
+        }
+        sign.setLine(Integer.parseInt(pArgs.get(0))-1, pArgs.get(1));
+        commandSender.sendMessage(ChatColor.GREEN + "Cedulka upravena");
+        sign.update();
+        return false;
+    }
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) {
+        return List.of();
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/commands/funHarvestBall.java

@@ -0,0 +1,31 @@
+package xyz.mineconomia.mineconomiacore.commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+
+public class funHarvestBall implements CommandExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) {
+        if (commandSender instanceof Player){
+            ItemStack ball = new ItemStack(Material.SNOWBALL, 16);
+            ItemMeta ballMeta = ball.getItemMeta();
+            assert ballMeta != null;
+            ballMeta.addEnchant(Enchantment.DURABILITY, 1, true);
+            ballMeta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
+            ballMeta.setDisplayName(ChatColor.AQUA + "Koule zábavného sklízení");
+            ball.setItemMeta(ballMeta);
+            ((Player) commandSender).getInventory().addItem(ball);
+
+        }
+        return false;
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/commands/gamble.java

@@ -0,0 +1,61 @@
+package xyz.mineconomia.mineconomiacore.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+import xyz.mineconomia.mineconomiacore.MineconomiaCore;
+import xyz.mineconomia.mineconomiacore.events.shopInteract;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class gamble implements CommandExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) {
+        Inventory gambleGui = Bukkit.createInventory(null, 27, "GAMBLE GAMBLE GAMBLE");
+        for (int i = 0; i<9; i++){
+            gambleGui.setItem( i,shopInteract.newItemStack(" ", Material.BLACK_STAINED_GLASS_PANE));
+            gambleGui.setItem( i + 18,shopInteract.newItemStack(" ", Material.BLACK_STAINED_GLASS_PANE));
+        }
+        gambleGui.setItem(4, shopInteract.newItemStack(" ", Material.LIME_STAINED_GLASS_PANE));
+        gambleGui.setItem(22, shopInteract.newItemStack(" ", Material.LIME_STAINED_GLASS_PANE));
+        Player p = (Player) commandSender;
+
+        List<ItemStack> itemStackList = new ArrayList<>();
+        for (Material m : Material.values()){
+            gambleGui.setItem(15, new ItemStack(m));
+            if (gambleGui.getItem(15) != null){
+                itemStackList.add(new ItemStack(m));
+            }
+        }
+        p.openInventory(gambleGui);
+        Collections.shuffle(itemStackList);
+        for(int i = 0; i < 100; i++){
+
+            Bukkit.getScheduler().scheduleSyncDelayedTask(MineconomiaCore.getPlugin(MineconomiaCore.class), new Runnable() {
+                public void run() {
+                    ItemStack itemStackToEnd = itemStackList.get(0);
+                    itemStackList.remove(0);
+                    itemStackList.add(itemStackToEnd);
+                    for (int i = 0; i<9; i++){
+                        gambleGui.setItem(i+9, itemStackList.get(i));
+                        if (gambleGui.getItem(i+9) == null){
+                            gambleGui.setItem(i+9, new ItemStack(Material.STICK));
+                        }
+                    }
+                    p.playSound(p, Sound.BLOCK_NOTE_BLOCK_BANJO, 100, 1);
+                }
+            }, Long.parseLong(String.valueOf(i+1)));
+        }
+        return true;
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/commands/mcore.java

@@ -2,11 +2,64 @@ package xyz.mineconomia.mineconomiacore.commands;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataType;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.mineconomia.mineconomiacore.PDC;
 
-public class mcore implements CommandExecutor {
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import static xyz.mineconomia.mineconomiacore.publicValues.config;
+
+public class mcore implements TabExecutor {
     @Override
-    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, String[] strings) {
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, String[] args) {
+        Player player = (Player) commandSender;
+        PlayerInventory inventory= player.getInventory();
+        ItemStack item = inventory.getItemInMainHand();
+        if (Objects.equals(args[0], "setSpecial")){
+
+            ItemMeta meta = item.getItemMeta();
+            assert meta != null;
+            PDC.WriteItemMetaPDC(meta, "special", PersistentDataType.INTEGER,1);
+            item.setItemMeta(meta);
+            config.set("special.item", item);
+            try {
+                config.save("config.yml");
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            return true;
+        }
+        if (Objects.equals(args[0], "setSellItem")){
+            config.set("sellItems." + item.getType().name(), Double.parseDouble(args[1]));
+            try {
+                config.save("config.yml");
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            player.sendMessage("Nastaveno");
+            return true;
+        }
         return false;
     }
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) {
+        List<String> completetions =  new ArrayList<>();
+
+                completetions.add("setSpecial");
+                completetions.add("setSellItem");
+
+        return completetions;
+    }
 }

src/main/java/xyz/mineconomia/mineconomiacore/commands/sample.java

@@ -0,0 +1,36 @@
+package xyz.mineconomia.mineconomiacore.commands;
+
+import com.arangodb.ArangoCollection;
+import com.arangodb.entity.BaseDocument;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import xyz.mineconomia.mineconomiacore.serialization;
+
+import java.io.IOException;
+import java.util.Map;
+
+import static xyz.mineconomia.mineconomiacore.database.database;
+
+public class sample implements CommandExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) {
+        ArangoCollection collection = database.collection("shops");
+        if (collection.documentExists(strings[0])){
+            BaseDocument baseDocument = collection.getDocument(strings[0], BaseDocument.class);
+            Map<String, Object> shopData = baseDocument.getProperties();
+            shopData.get("item");
+            try {
+                ((Player) commandSender).getInventory().addItem((ItemStack) serialization.stringToBukkitObject((String) shopData.get("item")));
+            } catch (IOException | ClassNotFoundException e) {
+                throw new RuntimeException(e);
+            }
+        }else{
+            commandSender.sendMessage("Shop není!");
+        }
+        return false;
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/commands/sell.java

@@ -0,0 +1,50 @@
+package xyz.mineconomia.mineconomiacore.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.persistence.PersistentDataType;
+import org.jetbrains.annotations.NotNull;
+import xyz.mineconomia.mineconomiacore.MineconomiaCore;
+import xyz.mineconomia.mineconomiacore.PDC;
+import xyz.mineconomia.mineconomiacore.events.sellClose;
+
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+public class sell implements CommandExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) {
+        Player player = (Player) commandSender;
+        if (strings.length > 0){
+            Map<String, List<Object>> MapOfSellable = sellClose.sellItems.get(player);
+            if (strings[0].equals("cancel") && !(MapOfSellable == null)){
+             NumberFormat formatter = new DecimalFormat("0.00");
+             Double finalPrice = 0d;
+             for (String key: sellClose.sellItems.get(player).keySet()){
+                 Integer count = (Integer) MapOfSellable.get(key).get(0);
+                 Double itemPrice = (Double) MapOfSellable.get(key).get(1);
+                 player.getInventory().addItem(new ItemStack( Objects.requireNonNull(Material.getMaterial(key.toUpperCase())), count));
+                 finalPrice += itemPrice;
+             }
+             sellClose.sellItems.remove(player);
+             MineconomiaCore.getEconomy().withdrawPlayer(player,finalPrice);
+             player.sendMessage(ChatColor.YELLOW +"Věci ti byli navráceny");
+             return true;
+         }
+        }
+        PDC.WritePlayerPDC(player, "sellGUIOpen", PersistentDataType.INTEGER, 1);
+        sellClose.sellItems.remove(player);
+        player.openInventory(Bukkit.createInventory(null, 36, ChatColor.DARK_GREEN + "" + ChatColor.BOLD + "Vlož itemy k prodeji"));
+        return true;
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/commands/setSign.java

@@ -0,0 +1,48 @@
+package xyz.mineconomia.mineconomiacore.commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.block.Sign;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.mineconomia.mineconomiacore.handlers.SignHandler;
+
+import java.util.List;
+
+import static xyz.mineconomia.mineconomiacore.MineconomiaCore.getArgs;
+
+public class setSign implements TabExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+
+        StringBuilder argsString = new StringBuilder();
+        for (String ss : args) {
+            argsString.append(ChatColor.translateAlternateColorCodes('&', ss)).append(" ");
+        }
+        List<String> pArgs = getArgs(argsString.toString());
+        if (pArgs.size() != 4){
+            commandSender.sendMessage(ChatColor.RED + "špatný počet argumentů");
+            return false;
+        }
+        Player player = (Player) commandSender;
+
+        if (!(player.getTargetBlock(null, 5).getState() instanceof Sign sign)){
+
+            commandSender.sendMessage(ChatColor.RED + "musíš se dívat na cedulku");
+            return false;
+        }
+        SignHandler.changeSignText(sign, pArgs.get(0), pArgs.get(1), pArgs.get(2), pArgs.get(3));
+        commandSender.sendMessage(ChatColor.GREEN + "Cedulka nastavena");
+        sign.update();
+        return false;
+    }
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) {
+        return List.of();
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/commands/shop.java

@@ -0,0 +1,141 @@
+package xyz.mineconomia.mineconomiacore.commands;
+
+import com.arangodb.ArangoCollection;
+import com.arangodb.entity.BaseDocument;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.block.*;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.persistence.PersistentDataType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import xyz.mineconomia.mineconomiacore.PDC;
+import xyz.mineconomia.mineconomiacore.events.specialEvents;
+import xyz.mineconomia.mineconomiacore.handlers.SignHandler;
+import xyz.mineconomia.mineconomiacore.serialization;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+
+import static xyz.mineconomia.mineconomiacore.publicValues.config;
+import static xyz.mineconomia.mineconomiacore.database.database;
+
+public class shop implements TabExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] args) {
+        if (args.length != 3){
+            commandSender.sendMessage(ChatColor.RED + "Špatné množství argumentů");
+            return false;
+        }
+        if (!(commandSender instanceof Player player)){
+            commandSender.sendMessage(ChatColor.RED + "Musíš být hráč");
+            return false;
+        }
+        if (specialEvents.specialPreLocations.get(player) == null){
+            commandSender.sendMessage(ChatColor.RED + "Musíš mít označenou cedulku a úložiště!");
+            return false;
+        }
+        if (!(specialEvents.specialPreLocations.get(player).size() == 2)){
+            commandSender.sendMessage(ChatColor.RED + "Musíš mít označenou cedulku a úložištěě");
+            return false;
+        }
+        BlockState block1 = specialEvents.specialPreLocations.get(player).get("loc1").getBlock().getState();
+        BlockState block2 = specialEvents.specialPreLocations.get(player).get("loc2").getBlock().getState();
+
+        Container container;
+        if (block1 instanceof Container){
+            container = (Container) block1;
+        } else if (block2 instanceof Container) {
+            container = (Container) block2;
+        }else {
+            commandSender.sendMessage(ChatColor.RED + "Nemáš ozačené úložiště");
+            return false;
+        }
+        Sign sign;
+        if (block1 instanceof Sign){
+            sign = (Sign) block1;
+        } else if (block2 instanceof Sign) {
+            sign = (Sign) block2;
+        }else {
+            commandSender.sendMessage(ChatColor.RED + "Nemáš označenou cedulku");
+            return false;
+        }
+        ItemStack handyItem = player.getInventory().getItemInMainHand().clone();
+        if (handyItem.getType() == Material.AIR){
+            commandSender.sendMessage(ChatColor.RED + "Nemáš v ruce item, který chceš prodávat");
+            return false;
+        }
+        if (handyItem == config.get("special.item")){
+            commandSender.sendMessage(ChatColor.RED + "Nemůžeš prodat pravítko. nečekaně...");
+            return false;
+        }
+        if (!isDouble(args[1]) || !isDouble(args[2])){
+            commandSender.sendMessage(ChatColor.RED + "Cena a počet kusů musí být čísla!");
+            return false;
+        }
+        BaseDocument shopDocument = new BaseDocument(""+ UUID.randomUUID());
+        String shopRegime;
+        switch (args[0]){
+            case "buy":
+            case "prodej":
+                shopRegime = "buy";
+                break;
+            case "sell":
+            case "výkup":
+                shopRegime = "sell";
+                break;
+            default:
+                commandSender.sendMessage(ChatColor.RED + "Neplatný režim obchodu");
+                return false;
+        }
+        shopDocument.addAttribute("signLocation", serialization.bukkitObjectToString(sign.getLocation()));
+        shopDocument.addAttribute("signX", sign.getX());
+        shopDocument.addAttribute("signY", sign.getY());
+        shopDocument.addAttribute("signZ", sign.getZ());
+        shopDocument.addAttribute("signW", sign.getWorld().toString());
+        shopDocument.addAttribute("containerLocation", serialization.bukkitObjectToString(container.getLocation()));
+        shopDocument.addAttribute("containerX", container.getX());
+        shopDocument.addAttribute("containerY", container.getY());
+        shopDocument.addAttribute("containerZ", container.getZ());
+        shopDocument.addAttribute("containerW", container.getWorld().toString());
+        shopDocument.addAttribute("owner", player.getDisplayName());
+        shopDocument.addAttribute("count",   Math.round(Long.parseLong(args[1])));
+        shopDocument.addAttribute("price", Long.parseLong(args[2]));
+        shopDocument.addAttribute("type", "playerLimited");
+        shopDocument.addAttribute("regime", shopRegime);
+        handyItem.setAmount(1);
+        shopDocument.addAttribute("itemName", Objects.requireNonNull(handyItem.getItemMeta()).getDisplayName());
+        shopDocument.addAttribute("item", serialization.bukkitObjectToString(handyItem));
+        shopDocument.addAttribute("itemType", handyItem.getType());
+        PDC.WriteTileStatePDC(sign, "shop", PersistentDataType.STRING, shopDocument.getKey());
+        SignHandler.changeSignText(sign, player.getDisplayName(), shopRegime, args[2] + "$/" + args[1] + "ks", handyItem.getType().name().toLowerCase());
+        sign.update();
+        PDC.WriteTileStatePDC(container, "storage", PersistentDataType.STRING, shopDocument.getKey());
+        ArangoCollection shopCollection = database.collection("shops");
+        shopCollection.insertDocument(shopDocument);
+        commandSender.sendMessage(ChatColor.GREEN + "Obchod vytvořen");
+        return true;
+
+    }
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) {
+        return List.of();
+    }
+
+    public boolean isDouble(String input ) {
+        try {
+            Double.parseDouble(input);
+            return true;
+        }
+        catch( Exception e ) {
+            return false;
+        }
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/commands/spawn.java

@@ -0,0 +1,18 @@
+package xyz.mineconomia.mineconomiacore.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class spawn implements CommandExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, @NotNull String[] strings) {
+        ((Player) commandSender).teleport(Objects.requireNonNull(Bukkit.getWorld("world")).getSpawnLocation());
+        return false;
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/commands/tpw.java

@@ -0,0 +1,41 @@
+package xyz.mineconomia.mineconomiacore.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class tpw implements CommandExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s, String[] args) {
+        if (commandSender instanceof Player){
+            if (args.length > 0){
+                if (Bukkit.getWorld(args[0]) != null){
+                    commandSender.sendMessage(ChatColor.AQUA + "Budeš teleportován!");
+                    World world = Bukkit.getWorld(args[0]);
+                    Player player = (Player) commandSender;
+                    assert world != null;
+                    player.teleport(world.getSpawnLocation());
+                    return true;
+                }else {
+                    commandSender.sendMessage(ChatColor.RED + "Svět neexistuje");
+                    commandSender.sendMessage(ChatColor.YELLOW + "Dostupné světy:");
+                    for (World world: Bukkit.getWorlds()){
+                        commandSender.sendMessage(world.getName());
+                    }
+                }
+            }else{
+                commandSender.sendMessage("Musíš definovat svět. /tpw <svět>");
+            }
+
+        }else {
+            commandSender.sendMessage(ChatColor.RED + "Pouze pro hráče.");
+        }
+        return false;
+    }
+}
+

src/main/java/xyz/mineconomia/mineconomiacore/completers/mcore_completer.java

@@ -1,5 +0,0 @@
-package xyz.mineconomia.mineconomiacore.completers;
-//Zde nic zatím
-public class mcore_completer {
-
-}

src/main/java/xyz/mineconomia/mineconomiacore/database.java

@@ -0,0 +1,17 @@
+package xyz.mineconomia.mineconomiacore;
+
+import com.arangodb.ArangoDB;
+import com.arangodb.ArangoDatabase;
+import com.arangodb.Protocol;
+import org.bukkit.configuration.file.FileConfiguration;
+
+public interface database {
+    FileConfiguration config = MineconomiaCore.getPlugin(MineconomiaCore.class).getConfig();
+    //creates public db session that can be acessed by the rest of plugin
+    ArangoDB arangodb = new ArangoDB.Builder()
+            .host(config.getString("database.host"), config.getInt("database.port"))
+            .user(config.getString("database.user"))
+            .password(config.getString("database.password"))
+            .build();
+    ArangoDatabase database = arangodb.db(config.getString("database.database"));
+}

src/main/java/xyz/mineconomia/mineconomiacore/events/playerAccount.java

@@ -0,0 +1,33 @@
+package xyz.mineconomia.mineconomiacore.events;
+
+import com.arangodb.ArangoCollection;
+import com.arangodb.entity.BaseDocument;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import xyz.mineconomia.mineconomiacore.MineconomiaCore;
+
+import java.util.Map;
+
+import static xyz.mineconomia.mineconomiacore.database.database;
+
+public class playerAccount implements Listener {
+    @EventHandler
+    public static void createAccout(PlayerJoinEvent event){
+        Player player = event.getPlayer();
+        String playerName = player.getDisplayName();
+        ArangoCollection playersCollection = database.collection("players");
+
+        if (!playersCollection.documentExists(playerName)){
+            BaseDocument playerDocument = new BaseDocument(playerName);
+            playerDocument.addAttribute("money", 0);
+            playerDocument.addAttribute("rank", "default");
+            playersCollection.insertDocument(playerDocument);
+        }else {
+            BaseDocument playerDocument = playersCollection.getDocument(playerName, BaseDocument.class);
+            Map<String, Object> playerProperties = playerDocument.getProperties();
+            MineconomiaCore.getPlugin(MineconomiaCore.class).getLogger().info(String.valueOf(playerProperties.get("money")));
+        }
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/events/sellClose.java

@@ -0,0 +1,83 @@
+package xyz.mineconomia.mineconomiacore.events;
+
+import net.md_5.bungee.api.chat.ClickEvent;
+import net.md_5.bungee.api.chat.ComponentBuilder;
+import net.md_5.bungee.api.chat.HoverEvent;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.persistence.PersistentDataType;
+import xyz.mineconomia.mineconomiacore.MineconomiaCore;
+import xyz.mineconomia.mineconomiacore.PDC;
+
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static xyz.mineconomia.mineconomiacore.publicValues.config;
+
+public class sellClose implements Listener {
+    public static HashMap<Player, Map<String, List<Object>>> sellItems = new HashMap<>();
+    @EventHandler
+    public void sellItemsPrep(InventoryCloseEvent event){
+        Player player = (Player) event.getPlayer();
+        if (PDC.GetPlayerPDC(player, "sellGUIOpen", PersistentDataType.INTEGER) == null){
+            return;
+        }
+
+        Inventory inventory = event.getInventory();
+        ItemStack[] itemStacks = inventory.getContents();
+        PDC.DeletePlayerPDC(player, "sellGUIOpen");
+        HashMap<String, List<Object>> MapOfSellable = new HashMap<>();
+        for (ItemStack itemStack: itemStacks){
+            if (itemStack != null){
+                String type = itemStack.getType().toString();
+                double price = config.getDouble("sellItems." + type);
+                if (price != 0){
+                    MapOfSellable.computeIfAbsent(type, k -> List.of(0, 0D));
+                    Integer finalCount = (Integer) MapOfSellable.get(type).get(0);
+                    Double finalPrice = (Double) MapOfSellable.get(type).get(1);
+                    int count = itemStack.getAmount();
+                    MapOfSellable.put(type, List.of(count+finalCount, price*count + finalPrice));
+                }else {
+                    player.getInventory().addItem(itemStack);
+                }
+            }
+
+        }
+        if(MapOfSellable.isEmpty()){
+            player.sendMessage(ChatColor.YELLOW + "Nic jsi neprodal");
+            return;
+        }
+        sellItems.put(player, MapOfSellable);
+        player.sendMessage("");
+        player.sendMessage(ChatColor.GREEN + "Prodal následující itemy:");
+        NumberFormat formatter = new DecimalFormat("0.00");
+        Double finalPrice = 0D;
+        for (String key: MapOfSellable.keySet()){
+            Integer count = (Integer) MapOfSellable.get(key).get(0);
+            Double itemPrice = (Double) MapOfSellable.get(key).get(1);
+            finalPrice += itemPrice;
+            player.sendMessage(ChatColor.YELLOW + "" + count + "x " + key.toLowerCase() + " za " + formatter.format(itemPrice) + "$");
+        }
+        TextComponent succesMessage = new TextComponent(ChatColor.GREEN + "Celkový zisk: "  +  formatter.format(finalPrice) + "$ ");
+        TextComponent cancelMessage = new TextComponent(ChatColor.RED + "" + ChatColor.BOLD + "ZRUŠIT");
+        cancelMessage.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT,  new ComponentBuilder(ChatColor.YELLOW + "Kliknutím se ti navratí itemy a odečtou peníze").create()));
+        cancelMessage.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/sell cancel"));
+        succesMessage.addExtra(cancelMessage);
+        player.spigot().sendMessage(succesMessage);
+        player.sendMessage("");
+        MineconomiaCore.getEconomy().depositPlayer(player, finalPrice);
+
+
+    }
+
+}

src/main/java/xyz/mineconomia/mineconomiacore/events/shopGuiInteract.java

@@ -0,0 +1,127 @@
+package xyz.mineconomia.mineconomiacore.events;
+
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryAction;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import xyz.mineconomia.mineconomiacore.MineconomiaCore;
+import xyz.mineconomia.mineconomiacore.invTools;
+import xyz.mineconomia.mineconomiacore.serialization;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+
+public class shopGuiInteract implements Listener {
+    public static HashMap<Player, Map<String, Object>> storeDatas = new HashMap<>();
+    @EventHandler
+    public void clickEvent(InventoryClickEvent event) throws IOException, ClassNotFoundException {
+        Player player = (Player) event.getWhoClicked();
+        Map<String, Object> storeData = storeDatas.get(player);
+
+        if (storeData == null) return;
+
+        event.setCancelled(true);
+
+        if (!event.getAction().equals(InventoryAction.PICKUP_ALL)) return;
+
+        String noSpaceMessage;
+        String noMoneyMessage;
+        String successUserMessage;
+        String successUserMessageEight;
+        String successOwnerMessage;
+        String successOwnerMessageEight;
+        String noItemsMessage;
+        String count = (String) storeData.get("count");
+        String price = (String) storeData.get("price");
+        String countEight = (String) storeData.get("countEight");
+        String priceEight = (String) storeData.get("priceEight");
+        String itemType = ((String) storeData.get("itemType")).toLowerCase();
+        ItemStack item = (ItemStack) serialization.stringToBukkitObject((String) storeData.get("item"));
+        Inventory buyerInventory = (Inventory) storeData.get("buyerInventory");
+        Inventory sellerInventory = (Inventory) storeData.get("sellerInventory");
+        OfflinePlayer buyer = (OfflinePlayer) storeData.get("buyer");
+        OfflinePlayer seller = (OfflinePlayer) storeData.get("seller");
+        OfflinePlayer owner = Bukkit.getOfflinePlayer((String) storeData.get("owner"));
+        Economy eco = MineconomiaCore.getEconomy();
+
+        if (storeData.get("regime").equals("buy")){
+            noSpaceMessage = ChatColor.RED + "Nemáš dost místa v inventáři";
+            noMoneyMessage = ChatColor.RED + "Nemáš dost peněz";
+            noItemsMessage = ChatColor.RED + "Prodejce nemá dost itemů ve skladišti";
+            successUserMessage = ChatColor.GREEN + "Koupil jsi " + count + "x " + itemType + " za " + price + "$";
+            successUserMessageEight = ChatColor.GREEN + "Koupil jsi " + countEight + "x " + itemType + " za " + priceEight + "$";
+            successOwnerMessage = ChatColor.GREEN + "Hráč " + player.getDisplayName() + " si koupil " + count + "x " + itemType + " za " + price + "$";
+            successOwnerMessageEight = ChatColor.GREEN + "Hráč " + player.getDisplayName() + " si koupil " + countEight + "x " + itemType + " za " + priceEight + "$";
+        }else{
+            noSpaceMessage = ChatColor.RED + "Prodejce nemá dost místa ve skladišti";
+            noMoneyMessage = ChatColor.RED + "Prodejce nemá dost peněz";
+            noItemsMessage = ChatColor.RED + "Nemáš dost itemů";
+            successUserMessage = ChatColor.GREEN + "Prodal jsi " + count + "x " + itemType + " za " + price + "$";
+            successUserMessageEight = ChatColor.GREEN + "Prodal jsi " + countEight + "x " + itemType + " za " + priceEight + "$";
+            successOwnerMessage = ChatColor.GREEN + "Hráč " + player.getDisplayName() + " ti prodal " + count + "x " + itemType + " za " + price + "$";
+            successOwnerMessageEight = ChatColor.GREEN + "Hráč " + player.getDisplayName() + " ti prodal " + countEight + "x " + itemType + " za " + priceEight + "$";
+
+        }
+        double finalPrice = Double.parseDouble(price);
+        int finalCount = Integer.parseInt(count);
+        int slot = event.getSlot();
+        if (slot == 1){
+            finalCount = Integer.parseInt(countEight);
+            finalPrice = Double.parseDouble(priceEight);
+        }
+        if (slot == 0 || slot == 1){
+            if (seller.equals(buyer)){
+                player.sendMessage(ChatColor.RED + "Sám sobě nic prodat nemůžeš");
+                return;
+            }
+            if(invTools.getFreeSpaceForItem(buyerInventory, item) < finalCount){
+                player.sendMessage(noSpaceMessage);
+                return;
+            }
+            if (finalPrice > eco.getBalance(buyer)){
+                player.sendMessage(noMoneyMessage);
+                return;
+            }
+            if (invTools.itemAmount(sellerInventory, item) < finalCount){
+                player.sendMessage(noItemsMessage);
+                return;
+            }
+
+            item.setAmount(finalCount);
+            sellerInventory.removeItem(item);
+            buyerInventory.addItem(item);
+            eco.withdrawPlayer(buyer, finalPrice);
+            eco.depositPlayer(seller, finalPrice);
+            if (slot == 0){
+                player.sendMessage(successUserMessage);
+                sendIfOnline(owner, successOwnerMessage);
+            }else{
+                player.sendMessage(successUserMessageEight);
+                sendIfOnline(owner, successOwnerMessageEight);
+            }
+
+        }
+
+    }
+    @EventHandler
+    public void closeEvent(InventoryCloseEvent event){
+        Player player = (Player) event.getPlayer();
+        storeDatas.remove(player);
+    }
+
+    public static void sendIfOnline(OfflinePlayer player, String message){
+        if (player.isOnline()) Objects.requireNonNull(player.getPlayer()).sendMessage(message);
+    }
+
+}

src/main/java/xyz/mineconomia/mineconomiacore/events/shopInteract.java

@@ -0,0 +1,140 @@
+package xyz.mineconomia.mineconomiacore.events;
+
+import com.arangodb.ArangoCollection;
+import com.arangodb.entity.BaseDocument;
+import org.bukkit.*;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.Container;
+import org.bukkit.block.Sign;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataType;
+import xyz.mineconomia.mineconomiacore.PDC;
+import xyz.mineconomia.mineconomiacore.serialization;
+
+import java.io.IOException;
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.util.*;
+
+import static xyz.mineconomia.mineconomiacore.database.database;
+
+public class shopInteract implements Listener {
+
+    @EventHandler
+    public static void savePosition(PlayerInteractEvent event) throws IOException, ClassNotFoundException {
+    if (event.getAction() == Action.RIGHT_CLICK_BLOCK){
+        Player player = event.getPlayer();
+        BlockState blockState = Objects.requireNonNull(event.getClickedBlock()).getState();
+        if (blockState instanceof Sign sign){
+            if (PDC.GetTileStatePDC(sign, "shop", PersistentDataType.STRING) != null){
+                ArangoCollection collection = database.collection("shops");
+                event.setCancelled(true);
+                String shopid = (String) PDC.GetTileStatePDC(sign, "shop", PersistentDataType.STRING);
+                player.sendMessage(ChatColor.GREEN + "Načítám data obchodu...");
+                if (collection.documentExists(shopid)){
+                    BaseDocument baseDocument = collection.getDocument(shopid, BaseDocument.class);
+                    Map<String, Object> shopData = baseDocument.getProperties();
+                    NumberFormat formatInteger = new DecimalFormat("0");
+                    NumberFormat formatter = new DecimalFormat("0.00");
+                    String regime = (String) shopData.get("regime");
+                    String ownerPrefix = "";
+                    if (((String) shopData.get("type")).contains("group")){
+                        ownerPrefix = "Skupina ";
+                    }
+                    String count = (String) formatInteger.format(shopData.get("count"));
+                    String price = formatter.format( shopData.get("price"));
+                    String countEight = formatInteger.format(Math.multiplyExact((Long) shopData.get("count"), 8));
+                    String priceEight = formatter.format(Math.multiplyExact((Long) shopData.get("price"),8));
+                    Inventory inventory;
+                    Inventory sellerInventory;
+                    Inventory buyerInventory;
+                    String shopPrefix;
+                    OfflinePlayer buyer;
+                    OfflinePlayer seller;
+
+                    String shopErrorMoney;
+                    String shopErrorProduct;
+                    Material shopMaterial;
+                    Material shopErrorMaterial;
+                    if (shopData.get("regime").equals("buy")) {
+                        sellerInventory = ((Container) ((Location) serialization.stringToBukkitObject((String) shopData.get("containerLocation"))).getBlock().getState()).getInventory();
+                        buyerInventory = player.getInventory();
+                        shopPrefix = "&aKoupit ";
+                        shopMaterial = Material.LIME_WOOL;
+                        shopErrorMaterial = Material.LIME_STAINED_GLASS;
+                        inventory = Bukkit.createInventory(null, 9, ChatColor.DARK_GREEN+ ""+ChatColor.BOLD +"Prodej");
+                        shopErrorMoney = "&cNemáš dost peněz";
+                        shopErrorProduct = "&cMajitel nemá dostatek itemů";
+                        buyer = player;
+                        seller = Bukkit.getOfflinePlayer((String) shopData.get("owner"));
+
+                    }else{
+                        sellerInventory = player.getInventory();;
+                        buyerInventory = ((Container) ((Location) serialization.stringToBukkitObject((String) shopData.get("containerLocation"))).getBlock().getState()).getInventory();
+                        shopPrefix = "&eProdat ";
+                        shopMaterial = Material.YELLOW_WOOL;
+                        shopErrorMaterial = Material.YELLOW_STAINED_GLASS;
+                        inventory = Bukkit.createInventory(null, 9, ChatColor.GOLD + ""+ ChatColor.BOLD +"Výkup");
+                        shopErrorMoney = "&cMajitel nemá dost peněz";
+                        shopErrorProduct = "&cNemáš dostatek itemů";
+                        buyer = Bukkit.getOfflinePlayer((String) shopData.get("owner"));
+                        seller = player;
+                    }
+
+                    inventory.setItem(0, newItemStack(shopPrefix + count + "ks za " + price + "$", shopMaterial));
+                    inventory.setItem(1, newItemStack(shopPrefix +  countEight + "ks za " + priceEight + "$", shopMaterial));
+                    inventory.setItem(7, (ItemStack) serialization.stringToBukkitObject((String) shopData.get("item")));
+                    inventory.setItem(8, newItemStack("&l&bInformace o obchodu:", Material.PLAYER_HEAD, List.of("&eMajitel: " + ownerPrefix + shopData.get("owner"))));
+                    shopData.put("buyerInventory", buyerInventory);
+                    shopData.put("sellerInventory", sellerInventory);
+                    shopData.put("seller", seller);
+                    shopData.put("buyer", buyer);
+                    shopData.put("price", price);
+                    shopData.put("priceEight", priceEight);
+                    shopData.put("count", count);
+                    shopData.put("countEight", countEight);
+                    shopGuiInteract.storeDatas.put(player, shopData);
+                    player.openInventory(inventory);
+
+
+
+
+
+                }else{
+                    player.sendMessage(ChatColor.RED + "Data obchodu nebyla nalezena");
+                }
+
+            }
+        }
+    }
+    }
+    public static ItemStack newItemStack(String name, Material material){
+        ItemStack itemStack = new ItemStack(material);
+        ItemMeta itemMeta = itemStack.getItemMeta();
+        assert itemMeta != null;
+        itemMeta.setDisplayName(ChatColor.translateAlternateColorCodes('&', name));
+        itemStack.setItemMeta(itemMeta);
+        return itemStack;
+    }
+    public static ItemStack newItemStack(String name, Material material, List<String> list){
+        ItemStack itemStack = new ItemStack(material);
+        ItemMeta itemMeta = itemStack.getItemMeta();
+        assert itemMeta != null;
+        itemMeta.setDisplayName(ChatColor.translateAlternateColorCodes('&', name));
+        List<String> lore = new ArrayList<>();
+        for (String loreline: list){
+            lore.add(ChatColor.translateAlternateColorCodes('&', loreline));
+        }
+        itemMeta.setLore(lore);
+        itemStack.setItemMeta(itemMeta);
+        return itemStack;
+    }
+
+}

src/main/java/xyz/mineconomia/mineconomiacore/events/signComplete.java

@@ -0,0 +1,19 @@
+package xyz.mineconomia.mineconomiacore.events;
+
+import org.bukkit.ChatColor;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.SignChangeEvent;
+
+
+import java.util.Objects;
+
+public class signComplete implements Listener {
+    @EventHandler
+    public void signCreate(SignChangeEvent event){
+
+        for (int i = 0; 4 > i; i++){
+            event.setLine(i, ChatColor.translateAlternateColorCodes('&', Objects.requireNonNull(event.getLine(i))));
+        }
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/events/spawnRadiusMessage.java

@@ -0,0 +1,41 @@
+package xyz.mineconomia.mineconomiacore.events;
+
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Color;
+import org.bukkit.boss.BarColor;
+import org.bukkit.boss.BarStyle;
+import org.bukkit.boss.BossBar;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+
+import java.util.HashMap;
+import java.util.Objects;
+
+public class spawnRadiusMessage implements Listener {
+    public static HashMap<Player, BossBar> playerBossBarWarn = new HashMap<>();
+    @EventHandler
+    public void detectIfPlayerIsInSpawnProtectRadius(PlayerMoveEvent event){
+        Player player = event.getPlayer();
+        if (!Objects.requireNonNull(player.getLocation().getWorld()).equals(Bukkit.getWorld("world"))){
+            return;
+        }
+        if (player.getLocation().distance(Objects.requireNonNull(Bukkit.getWorld("world")).getSpawnLocation()) < 300){
+            if (!playerBossBarWarn.containsKey(player)){
+                BossBar bossBar = Bukkit.createBossBar(ChatColor.YELLOW +"Jsi v obchodní zóně", BarColor.YELLOW, BarStyle.SOLID);
+                bossBar.setProgress(1);
+                bossBar.addPlayer(player);
+                playerBossBarWarn.put(player, bossBar);
+            }
+        }else{
+            if (playerBossBarWarn.containsKey(player)){
+                playerBossBarWarn.get(player).removeAll();
+                playerBossBarWarn.remove(player);
+            }
+
+        }
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/events/specialEvents.java

@@ -0,0 +1,120 @@
+package xyz.mineconomia.mineconomiacore.events;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.boss.BarColor;
+import org.bukkit.boss.BarStyle;
+import org.bukkit.boss.BossBar;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerItemHeldEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.persistence.PersistentDataType;
+import xyz.mineconomia.mineconomiacore.PDC;
+
+import java.util.HashMap;
+import java.util.Objects;
+
+
+//These events are handling every logic of the "special item"
+//Special item = item that is essential to marking blocks for interaction with plugin creation and edit functions
+public class specialEvents implements Listener {
+    //Stores informative boss bars
+    public static HashMap<Player, BossBar> specialBossBars = new HashMap<>();
+
+    //Stores locations marked by player using special item
+    public static HashMap<Player, HashMap<String, Location>> specialPreLocations = new HashMap<>();
+
+    //Checks if player is holding special item in hand and if so deploys boss bar
+    @EventHandler
+    public static void specialInHand(PlayerItemHeldEvent event){
+        Player player = event.getPlayer();
+        displayBossBar(player, player.getInventory().getItem(event.getNewSlot()));
+    }
+    @EventHandler
+    public static void savePosition(PlayerInteractEvent event){
+        Player player = event.getPlayer();
+        if (event.getItem() != null){
+            if (isSpecial(event.getItem())){
+                event.setCancelled(true);
+                switch (event.getAction()){
+                    case LEFT_CLICK_BLOCK:
+                        specialPreLocations.get(player).put("loc1", Objects.requireNonNull(event.getClickedBlock()).getLocation());
+                        break;
+                    case RIGHT_CLICK_BLOCK:
+                        specialPreLocations.get(player).put("loc2", Objects.requireNonNull(event.getClickedBlock()).getLocation());
+                }
+                displayBossBar(player, event.getItem());
+
+            }
+        }
+    }
+
+     private static void displayBossBar(Player player, ItemStack item){
+         if (!specialPreLocations.containsKey(player)){
+             specialPreLocations.put(player, new HashMap<>());
+         }
+         if (specialBossBars.get(player) == null){
+             BossBar bossBar = Bukkit.createBossBar( "", BarColor.YELLOW , BarStyle.SOLID);
+
+             specialBossBars.put(player, bossBar);
+         }
+         BossBar bossBar = specialBossBars.get(player);
+         if (item != null){
+             if (isSpecial(item)){
+                 String loc1String = "&6&lL &e(-,-,-,-)";
+                 String loc2String = "&e(-,-,-,-) &6&lP";
+
+                 HashMap<String, Location> playerLocations = specialPreLocations.get(player);
+                 bossBar.setProgress(0);
+
+                 if (playerLocations.containsKey("loc1")){
+                     Location loc1 = playerLocations.get("loc1");
+                     loc1String = "&6&lL &e("
+                             + loc1.getBlockX()
+                             + ","
+                             + loc1.getBlockY()
+                             + ","
+                             + loc1.getBlockZ()
+                             + ","
+                             + Objects.requireNonNull(loc1.getWorld()).getName()
+                             + ")";
+                 }
+                 if (playerLocations.containsKey("loc2")){
+                     Location loc2 = playerLocations.get("loc2");
+                     loc2String = "&e("
+                             + loc2.getBlockX()
+                             + ","
+                             + loc2.getBlockY()
+                             + ","
+                             + loc2.getBlockZ()
+                             + ","
+                             + Objects.requireNonNull(loc2.getWorld()).getName()
+                             + ") &6&lP";
+                 }
+
+                 String bossBarTitle = loc1String + "        " + loc2String;
+                 switch (playerLocations.size()){
+                     case 1:
+                         bossBar.setProgress(0.5);
+                         break;
+                     case 2:
+                         bossBarTitle = bossBarTitle.replace("&6","&2").replace("&e", "&a");
+                         bossBar.setColor(BarColor.GREEN);
+                         bossBar.setProgress(1);
+                 }
+                 bossBar.setTitle(ChatColor.translateAlternateColorCodes('&', bossBarTitle));
+                 bossBar.addPlayer(player);
+                 return;
+             }
+         }
+         bossBar.removePlayer(player);
+     }
+     private static boolean isSpecial(ItemStack itemStack){
+        return PDC.GetItemMetaPDC(Objects.requireNonNull(itemStack.getItemMeta()), "special", PersistentDataType.INTEGER) != null;
+    }
+
+}

src/main/java/xyz/mineconomia/mineconomiacore/events/toggleFrame.java

@@ -0,0 +1,35 @@
+package xyz.mineconomia.mineconomiacore.events;
+
+import org.bukkit.Particle;
+import org.bukkit.Sound;
+import org.bukkit.entity.*;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.inventory.EquipmentSlot;
+
+public class toggleFrame implements Listener {
+    @EventHandler
+    public void frameToggle(PlayerInteractEntityEvent event){
+        Entity entity = event.getRightClicked();
+        Player player = event.getPlayer();
+        if (entity.getType() != EntityType.ITEM_FRAME){
+            return;
+        }
+
+        if (!player.isSneaking()){
+            return;
+        }
+        event.setCancelled(true);
+        if (event.getHand() == EquipmentSlot.OFF_HAND) {
+            return;
+        }
+        ItemFrame itemFrame = (ItemFrame) entity;
+        itemFrame.setVisible(!itemFrame.isVisible());
+        player.playSound(itemFrame, Sound.ITEM_HOE_TILL, 100, 1);
+        player.spawnParticle(Particle.EXPLOSION_NORMAL, itemFrame.getLocation(), 0);
+
+
+
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/handlers/FHBHandler.java

@@ -0,0 +1,76 @@
+package xyz.mineconomia.mineconomiacore.handlers;
+
+import org.bukkit.*;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Snowball;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.inventory.ItemStack;
+import xyz.mineconomia.mineconomiacore.MineconomiaCore;
+import java.util.Objects;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
+public class FHBHandler implements Listener {
+
+    //experimentální... musí být později upraveno
+    @EventHandler
+    public void onFHBHit(ProjectileHitEvent event) throws InterruptedException {
+        if (event.getEntity() instanceof Snowball){
+            Snowball ball = (Snowball) event.getEntity();
+            MineconomiaCore.logger.info(ball.getCustomName());
+            if (Objects.equals(ball.getCustomName(), "kzs")){
+                if (event.getHitBlock() != null && event.getHitBlock().getType().equals(Material.FARMLAND)){
+                    Location loc = event.getHitBlock().getLocation();
+                    loc.setY(loc.getBlockY() + 1 );
+                    MineconomiaCore.logger.info(loc.getBlock().getType().toString());
+                    int cx = loc.getBlockX();
+                    int cy = loc.getBlockY();
+                    int cz = loc.getBlockZ();
+                    World w = loc.getWorld();
+                    int r = 10;
+                    int rSquared = r * r;
+                    for (int x = cx - r; x <= cx +r; x++) {
+                        for (int z = cz - r; z <= cz +r; z++) {
+                            if ((cx - x) * (cx - x) + (cz - z) * (cz - z) <= rSquared) {
+                                assert w != null;
+                                Block block = w.getBlockAt(x,cy,z);
+                                if (block.getType().equals(Material.WHEAT )){
+                                    Ageable wheatData = (Ageable) block.getBlockData();
+                                    if (wheatData.getAge() == 7){
+                                        wheatData.setAge(0);
+                                        w.playSound(block.getLocation(), "minecraft:block.crop.break", 100, 1);
+                                        Random rd = new Random();
+                                        w.playSound(block.getLocation(), "block.note_block.cow_bell", 100, rd.nextFloat());
+                                        block.setBlockData(wheatData);
+                                        w.dropItemNaturally(block.getLocation(), new ItemStack(Material.WHEAT, 1));
+                                        w.spawnParticle(Particle.EXPLOSION_NORMAL, block.getLocation(), 0);
+                                        TimeUnit.MILLISECONDS.sleep(20);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                MineconomiaCore.logger.info(Objects.requireNonNull(event.getHitBlock()).getType().toString());
+            }
+        }
+    }
+    @EventHandler
+    public void onFHBThrown(ProjectileLaunchEvent event){
+        if (event.getEntity() instanceof Snowball){
+            Snowball ball = (Snowball) event.getEntity();
+            if (ball.getShooter() instanceof Player){
+                Player player = (Player) ball.getShooter();
+                ItemStack item = player.getInventory().getItemInMainHand();
+                if (Objects.requireNonNull(item.getItemMeta()).getDisplayName().equals(ChatColor.AQUA + "Koule zábavného sklízení")){
+                    ball.setCustomName("kzs");
+                }
+            }
+        }
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/handlers/SignHandler.java

@@ -0,0 +1,25 @@
+package xyz.mineconomia.mineconomiacore.handlers;
+
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.bukkit.block.Sign;
+import org.bukkit.block.BlockState;
+
+import static xyz.mineconomia.mineconomiacore.MineconomiaCore.logger;
+
+
+public class SignHandler {
+
+    //Implement for
+    public static void changeSignText(Sign sign, String line0, String line1, String line2, String line3) {
+
+
+            //Nastavení textu
+            sign.setLine(0, line0);
+            sign.setLine(1, line1);
+            sign.setLine(2, line2);
+            sign.setLine(3, line3);
+            logger.info("successs");
+
+    }
+}

src/main/java/xyz/mineconomia/mineconomiacore/invTools.java

@@ -0,0 +1,35 @@
+package xyz.mineconomia.mineconomiacore;
+
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Objects;
+
+public class invTools {
+    public static int getFreeSpaceForItem(Inventory inventory, ItemStack itemStack){
+        int count = 0;
+        int stackSize = itemStack.getMaxStackSize();
+        for (int i = 0; inventory.getSize() > i; i++){
+            if (inventory.getItem(i) == null){
+                count += stackSize;
+            } else if (Objects.requireNonNull(inventory.getItem(i)).isSimilar(itemStack)) {
+                count += stackSize - Objects.requireNonNull(inventory.getItem(i)).getAmount();
+            }
+
+        }
+        return count;
+    }
+    public static int itemAmount(Inventory inventory, ItemStack itemStack){
+        int count = 0;
+        for(int i = 0; inventory.getSize() > i; i++){
+            ItemStack comparedItem = inventory.getItem(i);
+            if (comparedItem != null){
+                if (itemStack.isSimilar(comparedItem)){
+                    count += comparedItem.getAmount();
+                }
+            }
+        }
+        return count;
+    }
+
+}

src/main/java/xyz/mineconomia/mineconomiacore/publicValues.java

@@ -0,0 +1,12 @@
+package xyz.mineconomia.mineconomiacore;
+
+import com.arangodb.entity.BaseDocument;
+import org.bukkit.configuration.file.FileConfiguration;
+
+import java.util.HashMap;
+
+public interface publicValues {
+    FileConfiguration config = MineconomiaCore.getPlugin(MineconomiaCore.class).getConfig();
+    HashMap<String, Object> shops = new HashMap<>();
+}
+

src/main/java/xyz/mineconomia/mineconomiacore/serialization.java

@@ -0,0 +1,30 @@
+package xyz.mineconomia.mineconomiacore;
+
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.io.BukkitObjectInputStream;
+import org.bukkit.util.io.BukkitObjectOutputStream;
+
+import java.io.*;
+import java.util.Base64;
+
+public class serialization {
+    public static String bukkitObjectToString(Object object){
+        byte[] serializedObject = null;
+        try {
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            BukkitObjectOutputStream oos = new BukkitObjectOutputStream(baos);
+            oos.writeObject(object);
+            oos.close();
+            serializedObject = baos.toByteArray();
+
+        } catch (IOException e) {
+            MineconomiaCore.logger.info("it's fucked: " + e);
+        }
+        return Base64.getEncoder().encodeToString(serializedObject);
+    }
+    public static Object stringToBukkitObject(String string) throws IOException, ClassNotFoundException {
+        byte[] byteArray = Base64.getDecoder().decode(string);
+        BukkitObjectInputStream in = new BukkitObjectInputStream(new ByteArrayInputStream(byteArray));
+        return in.readObject();
+    }
+}

src/main/resources/config.yml

@@ -0,0 +1,7 @@
+database:
+  #ArangoDB is used
+  host: "localhost"
+  port: 8529
+  user: "user"
+  database: "database"
+  password: "password"

src/main/resources/plugin.yml

@@ -1,10 +1,36 @@
 name: MineconomiaCore
 version: '${project.version}'
 main: xyz.mineconomia.mineconomiacore.MineconomiaCore
-api-version: '1.20'
+api-version: '1.18'
 prefix: MCore
 authors: [Jakub Soukup, Richard Telka]
 commands:
   mcore:
     permission: mcore.admin
     description: "administrator's command"
+  tpw:
+    permission: mcore.admin
+    description: "administrator's command"
+  pomoc:
+    usage: "toto je potřeba někdy dodělat - Kubík"
+  fhb:
+    description: "dá kuzelnou kouli sklizně "
+    permission: mcore.fhb
+  shop:
+    description: "mgg nesnáším vysvětlování věcí, proč vůbec používáš help?"
+  sample:
+    description: will unfuck things
+    permission: mcore.unfuck
+  gamble:
+    description: "dd"
+    permission: mcore.gamble
+  sell:
+    description: "ff"
+  spawn:
+    description: "na spawn s tebou"
+  bed:
+    description: "do postele s tebou"
+  setSign:
+    description: ""
+  editSign:
+    description: ""