gq to me

change of domain name

src/main/java/me/unurled/raxen/Raxen.java

@@ -0,0 +1,141 @@
+package me.unurled.raxen;
+
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.ProtocolManager;
+import lombok.Getter;
+import me.unurled.raxen.config.Config;
+import me.unurled.raxen.config.PlayerConfig;
+import me.unurled.raxen.manager.Manager;
+import me.unurled.raxen.utils.Reload;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.logging.Logger;
+
+import static me.unurled.raxen.utils.Utils.colorComp;
+
+public final class Raxen extends JavaPlugin {
+
+    private static final String prefix = "<aqua>Rx</aqua><light_purple>></light_purple> ";
+    @Getter private static String version = "0.5.3";
+    private final PluginManager pm = getServer().getPluginManager();
+
+    private static Raxen plugin;
+
+    private static Logger logger;
+
+    private static Config config;
+
+    private static PlayerConfig playerConfig;
+
+    @Getter private ProtocolManager protocolManager;
+
+    @Getter private Manager manager;
+
+    /**
+     * Method when the server launch the plugin.
+     */
+    @Override
+    public void onEnable() {
+        plugin = this;
+        logger = getLogger();
+        version = plugin.getDescription().getVersion();
+        manager = new Manager();
+        manager.set(plugin);
+
+        // Config
+        config = new Config(plugin);
+
+        protocolManager = ProtocolLibrary.getProtocolManager();
+
+        playerConfig = new PlayerConfig(plugin);
+
+        //register Commands and Events
+        registerCommands();
+        registerEvents();
+
+        Bukkit.getConsoleSender().sendMessage(colorComp(prefix +"<green>Server Started Successfully!</green>"));
+
+        manager.getListenerManager().getServerPingEvent().setLoading(false);
+    }
+
+    /**
+     * register the command in the command manager class.
+     */
+    private void registerCommands() {
+        manager.getCommandManager().register();
+
+        Bukkit.getConsoleSender().sendMessage(colorComp(prefix +"<green>Commands Registered!</green>"));
+    }
+
+    /**
+     * register the events in the event manager class.
+     */
+    private void registerEvents() {
+        manager.getListenerManager().register();
+
+        Bukkit.getConsoleSender().sendMessage(colorComp(prefix +"<green>Events Registered!</green>"));
+    }
+
+    /**
+     * Method when the server stops the plugin.
+     */
+    @Override
+    public void onDisable() {
+        manager.getListenerManager().getServerPingEvent().setLoading(true);
+        Reload.kickAll();
+
+        playerConfig.close();
+
+        Bukkit.getConsoleSender().sendMessage(colorComp(prefix +"<red>Server Stopped Successfully!</red>"));
+    }
+
+    /**
+     * getter for the logger
+     * @return the plugin logger
+     */
+    public static Logger getPluginLogger() {
+        return logger;
+    }
+
+    /**
+     * getter for the bukkit's plugin manager
+     * @return plugin manager
+     */
+    public PluginManager getPm() {
+        return pm;
+    }
+
+    /**
+     * return the instance which is launched.
+     * @return main instance
+     */
+    public static Raxen getPlugin() {
+        return plugin;
+    }
+
+    /**
+     * getter for the raxen prefix
+     * @return string prefix
+     */
+    public static String getPrefix() {
+        return prefix;
+    }
+
+    /**
+     * getter for the yml's player configs.
+     * @return player config instance
+     */
+    public static PlayerConfig getPlayerConfig() {
+        return playerConfig;
+    }
+
+    /**
+     * getter for an instance of the config utility class
+     * @return raxen's config
+     */
+    public static Config getConf() {
+        return config;
+    }
+}

src/main/java/me/unurled/raxen/commands/RaxenCommand.java

@@ -0,0 +1,124 @@
+package me.unurled.raxen.commands;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.manager.entity.StorageManager;
+import net.kyori.adventure.text.TextComponent;
+import net.kyori.adventure.text.event.ClickEvent;
+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 java.util.List;
+
+import static me.unurled.raxen.utils.Utils.*;
+
+public class RaxenCommand implements TabExecutor {
+
+    private Raxen main;
+
+    public RaxenCommand(Raxen main) {
+        this.main = main;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command cmd, @NotNull String msg, @NotNull String[] args) {
+        if(sender instanceof Player) {
+            Player player = (Player) sender;
+            if(!(player.hasPermission("raxen."))) {
+                msgPlayer(player, coloredString(Raxen.getPrefix()) + colorTextComp("<red>You can't execute this command. Insufficient permission."));
+            }
+            switch (args.length) {
+                case 0 -> msgPl(player, 0);
+                case 1 -> {
+                    switch (args[0]) {
+                        case "mongodb", "mongo", "MONGODB", "MONGO" -> {
+                            //print info about connection
+                            sender.sendMessage(coloredString(Raxen.getPrefix()) + colorTextComp("<gold>Printing About Raxen's MongoDB connection..."));
+                            msgPlayer(player, coloredString(Raxen.getPrefix()) +
+                                    colorTextComp("<gold>---------------------------------------------"));
+                            msgPlayer(player, colorTextComp("<red>MONGO DB<white>"));
+                            msgPlayer(player, StorageManager.getMongodb().getMongoClient().getClusterDescription().toString());
+                            msgPlayer(player, StorageManager.getMongodb().getMongoDatabase().getName());
+                            msgPlayer(player, StorageManager.getMongodb().getMongoCollection().getNamespace().toString());
+                            msgPlayer(player, "<gold>---------------------------------------------");
+                        }
+                        case "v", "version", "ver" -> {
+                            msgPl(player, 0);
+                        }
+                        case "hemlp", "?", "h" -> {
+                            //print help
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            log(String.valueOf(args.length));
+            switch (args.length) {
+                case 0 -> {
+                    msgSender(sender, Raxen.getPrefix() + "<gold>Printing About Raxen...",
+                            "<gold>---------------------------------------------",
+                            "<dark_aqua>                   Raxen                     ",
+                            "<dark_aqua> - Version: " + Raxen.getVersion(),
+                            "<dark_aqua> - Author: <b><red>U<gold>n<yellow>u<dark_green>r<green>l<aqua>e<dark_aqua>d<reset>");
+                    TextComponent txt = colorTextComp("<dark_aqua> - Website: https://unurled.me");
+                    sender.sendMessage(txt);
+                    sender.sendMessage(coloredString("<gold>---------------------------------------------"));
+                    return true;
+                }
+                case 1 -> {
+                    switch (args[0]) {
+                        case "mongodb", "mongo", "MONGODB", "MONGO" -> {
+                            //print info about connection
+                            msgSender(sender, Raxen.getPrefix() + "<gold>Printing About Raxen's MongoDB connection...",
+                                    "<gold>---------------------------------------------" + "<red>MONGO DB");
+                            sender.sendMessage(StorageManager.getMongodb().getMongoClient().getClusterDescription().toString());
+                            sender.sendMessage(StorageManager.getMongodb().getMongoDatabase().getName());
+                            sender.sendMessage(StorageManager.getMongodb().getMongoCollection().getNamespace().toString());
+                            sender.sendMessage(coloredString("<gold>---------------------------------------------"));
+                            return true;
+                        }
+                        case "v", "version", "ver" -> {
+                            msgSender(sender, Raxen.getPrefix() + "<gold>Printing About Raxen...",
+                                    "<gold>---------------------------------------------",
+                                    "<dark_aqua>                   Raxen                     ",
+                                    "<dark_aqua> - Version: " + Raxen.getVersion(),
+                                    "<dark_aqua> - Author: <b><red>U<gold>n&eu<dark_green>r<green>l<aqua>e<dark_aqua>d<reset>");
+                            TextComponent txt=colorTextComp("<dark_aqua> - Website: https://unurled.me");
+                            sender.sendMessage(txt);
+                            sender.sendMessage(coloredString("<gold>---------------------------------------------"));
+                            return true;
+                        }
+                        case "hemlp", "?", "h" ->
+                                //print help
+                                debug(main, "print help");
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    public void msgPl(Player player, Integer in) {
+        switch(in) {
+            case 0:
+                msgPlayer(player, Raxen.getPrefix() + "<gold>Printing About Raxen...",
+                        "<gold>---------------------------------------------",
+                        "<dark_aqua>                   Raxen                     ",
+                        "<dark_aqua> - Version: " + Raxen.getVersion(),
+                        "<dark_aqua> - Author: <b><red>U<gold>n&eu<dark_green>r<green>l<aqua>e<dark_aqua>d<reset>");
+                TextComponent txt = (TextComponent) colorComp("<dark_aqua> - Website: https://unurled.me")
+                        .clickEvent(ClickEvent.openUrl("https://unurled.me"));
+                player.sendMessage(txt);
+                msgPlayer(player, "", "<gold>---------------------------------------------");
+        }
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
+        return null;
+    }
+}

src/main/java/me/unurled/raxen/commands/admin/CustomModelDataCommand.java

@@ -0,0 +1,97 @@
+package me.unurled.raxen.commands.admin;
+
+import org.bukkit.Material;
+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.util.StringUtil;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static me.unurled.raxen.utils.Items.customModelData;
+import static me.unurled.raxen.utils.Utils.*;
+public class CustomModelDataCommand implements TabExecutor {
+
+    /**
+     * change custom model data of an item
+     * @param sender  Source of the command 
+     * @param command Command which was executed
+     * @param label   Alias of the command which was used
+     * @param args    Passed command arguments
+     * @return
+     */
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (!(sender instanceof Player)) {
+            errorConsoleSender(sender);
+            return true;
+        }
+        Player p = (Player) sender;
+        if (!(p.hasPermission("raxen.custommodeldata.cmd"))) {
+            p.sendMessage(noPerms());
+            return true;
+        }
+        ItemStack it = p.getInventory().getItemInMainHand();
+        if (args.length == 0) {
+            p.sendMessage(colorComp("<gold>Usage: /custommodeldata <model-data-value> <item-name></gold>"));
+            return true;
+        }
+        if (!(isInt(args[0]))) {
+            Material material = Material.getMaterial(args[1]);
+            if (material != null) {
+                it = customModelData(new ItemStack(material), Integer.parseInt(args[0]));
+                p.getInventory().setItemInMainHand(it);
+                p.updateInventory();
+            } else {
+                p.sendMessage(colorComp("<red>Please specify a valid Item Name or a valid Integer.</red>"));
+            }
+        } else {
+            if (it != null && it.getType() != Material.AIR) { // check if player has an item in hand
+                // has item in hand applying the custom model data
+                it = customModelData(it, Integer.parseInt(args[0]));
+                p.getInventory().setItemInMainHand(it);
+                p.updateInventory();
+            } else {
+                p.sendMessage(colorComp("<red>Get an item in hand please or specify an item</red>"));
+                p.sendMessage(colorComp("<gold>Usage: /custommodeldata <model-data-value> <item-name></gold>"));
+            }
+        }
+        return true;
+    }
+
+    /**
+     * @param sender  Source of the command.  For players tab-completing a 
+     *                command inside of a command block, this will be the player, not
+     *                the command block.
+     * @param command Command which was executed
+     * @param label   Alias of the command which was used
+     * @param args    The arguments passed to the command, including final
+     *                partial argument to be completed
+     * @return
+     */
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        final List<String> completions = new ArrayList<>();
+
+        List<String> SUB_COMMANDS= new ArrayList<>();
+
+        if (!(isInt(args[0]))) {
+            return Arrays.asList( "§c" + args[0]);
+        }
+        if (args.length == 2) {
+            for (Material mat : Material.values()) {
+                SUB_COMMANDS.add(mat.name());
+            }
+            StringUtil.copyPartialMatches(args[1], SUB_COMMANDS, completions);
+            Collections.sort(completions);
+        }
+        return completions;
+    }
+}

src/main/java/me/unurled/raxen/commands/admin/ItemListCommand.java

@@ -0,0 +1,49 @@
+package me.unurled.raxen.commands.admin;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.gui.ItemListGui;
+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 java.util.List;
+
+import static me.unurled.raxen.utils.Utils.*;
+
+public class ItemListCommand implements TabExecutor {
+
+    private Raxen main;
+
+    @Getter
+    private ItemListGui itemListGui;
+
+    public ItemListCommand(Raxen main) {
+        this.main = main;
+        this.itemListGui = new ItemListGui(this.main);
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command cmd, @NotNull String msg, @NotNull String[] args) {
+        if (!(sender instanceof Player)) {
+            log("Console can't execute this command atm.");
+            return true;
+        }
+        Player player = (Player) sender;
+        if(!(player.hasPermission("raxen.itemlist.cmd"))) {
+            msgPlayer(player, colorString("<red>You'dont have the permission to execute this command."));
+            return true;
+        }
+        //openGui logic
+        player.openInventory(itemListGui.getInv());
+        return false;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
+        return null;
+    }
+}

src/main/java/me/unurled/raxen/commands/admin/NbtCommand.java

@@ -0,0 +1,108 @@
+package me.unurled.raxen.commands.admin;
+
+import de.tr7zw.nbtapi.NBTItem;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+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.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import static me.unurled.raxen.components.entity.player.PlayerUtils.updateSkills;
+import static me.unurled.raxen.utils.Utils.*;
+
+public class NbtCommand implements TabExecutor {
+
+    private final Raxen main;
+
+    public NbtCommand(Raxen main) {
+        this.main = main;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command cmd, @NotNull String msg, @NotNull String[] args) {
+        if(!(sender instanceof Player player)) {
+            error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),colorString("<red>You can't execute this command as the Console!"));
+            return true;
+        }
+        if(player.getInventory().getItemInMainHand().getType() == Material.AIR) {
+            msgPlayer(player,colorTextComp("<red>You must hold an Item in hand."));
+            return true;
+        } else {
+            player.getInventory().getItemInMainHand();
+        }
+        switch (args.length) {
+            case 0, 1 -> msgPlayer(player, colorTextComp("<red>You must specify an nbt and an int."));
+            case 2 -> {
+                debug(main, "'" + args[0] + "'", "'" + args[1] + "'");
+                ItemStack it = player.getInventory().getItemInMainHand();
+                NBTItem nbti = new NBTItem(it);
+                int a = 0;
+                if (nbti.hasKey(args[1])) {
+                    a = nbti.getInteger(args[1]);
+                }
+                List<Component> lore = new ArrayList<>();
+                ItemMeta itm = it.getItemMeta();
+                lore.add((Component) itm.lore());
+                boolean yes = false;
+                boolean ever = false;
+                for (Component ct : lore) {
+                    if (ct != null) {
+                        if (ct.contains(Component.text("Attributes:"))) {
+                            yes = true;
+                            ever = true;
+                        } else {
+                            if (yes) {
+                                //ct.append(Component.text(colorString(attributes(args[0]) + ": " + (Integer.parseInt(args[1]) + a)))); deprecated
+                                yes = false;
+                            }
+                        }
+                    }
+                }
+                if (!ever) {
+                    lore.add(colorTextComp("<red>Attributes:"));
+                    //lore.add(colorTextComp(attributes(args[0]) + ": " + (Integer.parseInt(args[1]) + a))); deprecated
+                }
+                itm.lore(lore);
+                it.setItemMeta(itm);
+                PlayerManager pm = ((Raxen) Objects.requireNonNull(Bukkit.getPluginManager().getPlugin("Raxen"))).getManager().getPlayerManager();
+                nbti.setInteger(args[0], Integer.parseInt(args[1]) + a);
+                if (nbti.hasKey("SPEED")) {
+                    pm.getSpeed().add(player, nbti.getInteger("SPEED"));
+                }
+                if (nbti.hasKey("HEALTH")) {
+                    pm.getHealth().add(player, nbti.getInteger("HEALTH"));
+                }
+                if (nbti.hasKey("DEFENSE")) {
+                    pm.getDefense().add(player, nbti.getInteger("DEFENSE"));
+
+                }
+                if (nbti.hasKey("STRENGTH")) {
+                    pm.getStrength().add(player, nbti.getInteger("STRENGTH"));
+                }
+                it = nbti.getItem();
+                msgPlayer(player, colorTextComp(Raxen.getPrefix() + "<white>You successfully added the nbt " + /*attributes(args[0])*/ args[0] + "<white>with " + args[1] + "<white>."));
+                updateSkills(main, player);
+                player.getInventory().setItem(player.getInventory().getHeldItemSlot(), it);
+            }
+        }
+        return true;
+    }
+
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
+        return null;
+    }
+}

src/main/java/me/unurled/raxen/commands/admin/ReloadCommand.java

@@ -0,0 +1,36 @@
+package me.unurled.raxen.commands.admin;
+
+import me.unurled.raxen.utils.Reload;
+import org.bukkit.Bukkit;
+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 java.util.List;
+
+import static me.unurled.raxen.utils.Utils.*;
+
+public class ReloadCommand implements TabExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String msg, @NotNull String[] args) {
+        if(sender instanceof Player) {
+            Player player = (Player) sender;
+            if(!player.hasPermission("raxen.reload.cmd")) {
+                player.sendMessage(noPerms());
+                return true;
+            }
+        }
+        Reload.kickAll();
+        log(colorString("<red>Server stopping!\n Using: /rlpl.\n Please wait a little bit."));
+        Bukkit.getServer().shutdown();
+        return false;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
+        return null;
+    }
+}

src/main/java/me/unurled/raxen/commands/admin/SpawnEntity.java

@@ -0,0 +1,58 @@
+package me.unurled.raxen.commands.admin;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.other.EntityNamespacedKey;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static me.unurled.raxen.components.entity.other.EntityUtils.setNameSpacedKeys;
+import static me.unurled.raxen.utils.Utils.*;
+
+public class SpawnEntity implements TabExecutor {
+
+    private Raxen main;
+    private EntityNamespacedKey namespacedKey;
+
+    public SpawnEntity(Raxen main) {
+        this.main = main;
+        this.namespacedKey = new EntityNamespacedKey(main);
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (!(sender instanceof Player)) {
+            log(colorString("<red>Console can't execute this command!"));
+            return false;
+        }
+        Player player = (Player) sender;
+        if (!player.hasPermission("raxen.entityspawn.cmd")) {
+            player.sendMessage(noPerms());
+            return false;
+        }
+        //example command : /entityspawn ZOMBIE "&cHello folks" 50 200
+        EntityType types = EntityType.valueOf(args[0]);
+        Entity e = player.getWorld().spawnEntity(player.getLocation(), types, false);
+        setNameSpacedKeys(e, "<red>Name", 100, 100,0,50,0,100,0,100,0);
+        e.customName(colorTextComp(args[1]));
+        e.setCustomNameVisible(true);
+        return false;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
+        List<String> list = new ArrayList<>();
+        for (EntityType types : EntityType.values()) {
+            list.add(types.name());
+        }
+        return list;
+    }
+}

src/main/java/me/unurled/raxen/commands/admin/TestGuiCommand.java

@@ -0,0 +1,36 @@
+package me.unurled.raxen.commands.admin;
+
+import org.bukkit.Bukkit;
+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 java.util.List;
+
+import static me.unurled.raxen.utils.Utils.colorTextComp;
+import static me.unurled.raxen.utils.Utils.log;
+
+public class TestGuiCommand implements TabExecutor {
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if(sender instanceof Player) {
+            Player player = (Player) sender;
+            if(player.hasPermission("raxen.test.gui.cmd")) {
+                player.openInventory(Bukkit.createInventory(null, 54, colorTextComp(args[0])));
+            }
+        }
+        else {
+            log("The console can't execute this Command!");
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
+        return null;
+    }
+}

src/main/java/me/unurled/raxen/commands/player/ClassCommand.java

@@ -0,0 +1,38 @@
+package me.unurled.raxen.commands.player;
+
+import me.unurled.raxen.Raxen;
+import org.bukkit.Bukkit;
+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 java.util.List;
+
+import static me.unurled.raxen.utils.Utils.error;
+
+public class ClassCommand implements TabExecutor {
+
+    private Raxen main;
+
+    public ClassCommand(Raxen main) {
+        this.main = main;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if(!(sender instanceof Player)) {
+            error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),"The console can't execute this Command!");
+            return true;
+        }
+        Player player = (Player) sender;
+        return false;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
+        return null;
+    }
+}

src/main/java/me/unurled/raxen/commands/player/MainGuiCommand.java

@@ -0,0 +1,63 @@
+package me.unurled.raxen.commands.player;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.gui.MainGui;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+import static me.unurled.raxen.utils.Utils.errorConsoleSender;
+import static me.unurled.raxen.utils.Utils.noPerms;
+
+public class MainGuiCommand implements TabExecutor {
+
+    private Raxen main;
+
+    public MainGuiCommand(Raxen main) {
+        this.main = main;
+    }
+
+    /**
+     * @param sender  Source of the command 
+     * @param command Command which was executed
+     * @param label   Alias of the command which was used
+     * @param args    Passed command arguments
+     * @return
+     */
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if (!(sender instanceof Player)) {
+            errorConsoleSender(sender);
+            return true;
+        }
+        Player p = (Player) sender;
+        if (!(p.hasPermission("raxen.maingui.cmd"))) {
+            sender.sendMessage(noPerms());
+            return true;
+        }
+        Inventory inv = MainGui.build(p);
+        p.openInventory(inv);
+        return true;
+    }
+
+    /**
+     * @param sender  Source of the command.  For players tab-completing a 
+     *                command inside of a command block, this will be the player, not
+     *                the command block.
+     * @param command Command which was executed
+     * @param label   Alias of the command which was used
+     * @param args    The arguments passed to the command, including final
+     *                partial argument to be completed
+     * @return
+     */
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        return null;
+    }
+}

src/main/java/me/unurled/raxen/commands/player/SkillsCommand.java

@@ -0,0 +1,68 @@
+package me.unurled.raxen.commands.player;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.player.PlayerUtils;
+import me.unurled.raxen.components.entity.player.attributes.Attributes;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.Bukkit;
+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 java.util.List;
+
+import static me.unurled.raxen.utils.Utils.colorTextComp;
+import static me.unurled.raxen.utils.Utils.error;
+
+public class SkillsCommand implements TabExecutor {
+
+    private Raxen main;
+
+    public SkillsCommand(Raxen main) {
+        this.main = main;
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String msg, @NotNull String[] args) {
+        if(!(sender instanceof Player)) {
+            error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),"The console can't execute this Command!");
+            return true;
+        }
+        Player player = (Player) sender;
+        Attributes attributes = new Attributes(main);
+        switch (args.length) {
+            case 0:
+                //open gui
+                player.sendMessage(colorTextComp("<red>GUI not implemented yet..").append(colorTextComp("<red>Try /skill help.")));
+                break;
+            case 1:
+            case 2:
+                player.sendMessage(colorTextComp("<white>Use the command like: ")
+                        .append(colorTextComp("<white>/skill <dark_aqua>{health|defense|speed|strength} {add|set|remove} {amount}")));
+                break;
+            case 3:
+                PlayerManager pm = ((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager().getPlayerManager();
+                for (String s : pm.getAttribute().keySet()) {
+                    if (s.equalsIgnoreCase(args[0]))
+                    switch (args[1]) {
+                        case "add":
+                            pm.getAttribute().get(s).add(player, Integer.parseInt(args[2]));
+                        case "remove":
+                            pm.getAttribute().get(s).remove(player, Integer.parseInt(args[2]));
+                        case "set":
+                            pm.getAttribute().get(s).set(player, Integer.parseInt(args[2]));
+                    }
+                }
+                PlayerUtils.updateSkills(main, player);
+        }
+        return false;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
+        return null;
+    }
+}

src/main/java/me/unurled/raxen/commands/player/StorageCommand.java

@@ -0,0 +1,57 @@
+package me.unurled.raxen.commands.player;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+import static me.unurled.raxen.utils.Utils.*;
+
+public class StorageCommand implements TabExecutor {
+
+    private PlayerManager playerManager;
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, @NotNull String[] args) {
+        if(!(sender instanceof Player)) {
+            error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),"The console can't execute this Command!");
+            return true;
+        }
+        Player player = (Player) sender;
+        Inventory inv;
+        playerManager = ((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager().getPlayerManager();
+        switch (args.length) {
+            case 0:
+                if(playerManager.getRaxenPlayer(player).getStorage() == null) {
+                    inv = playerManager.getRaxenPlayer(player).createStorage().getEc().getEc();
+                } else {
+                    inv = playerManager.getRaxenPlayer(player).getStorage().getEc().getEc();
+                }
+                player.openInventory(inv);
+                break;
+            case 1:
+                Player p = Bukkit.getPlayer(args[0]);
+                if(p == null) {
+                    msgPlayer(player, colorString("<red>You can't open the Storage of an unknown Player."));
+                    return true;
+                }
+                inv = playerManager.getRaxenPlayer(player).getStorage().getEc().getEc();
+                player.openInventory(inv);
+                break;
+        }
+        return true;
+    }
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command, @NotNull String alias, @NotNull String[] args) {
+        return null;
+    }
+}

src/main/java/me/unurled/raxen/components/dungeons/Dungeon.java

@@ -0,0 +1,66 @@
+package me.unurled.raxen.components.dungeons;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.dungeons.types.MonsterType;
+import me.unurled.raxen.components.entity.other.RaxenEntity;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+
+import java.util.HashMap;
+
+import static me.unurled.raxen.utils.DungeonUtils.getRadiusFromRank;
+
+public class Dungeon {
+
+    @Getter private String name;
+
+    @Getter private Rank rank;
+
+    @Getter private Gate gate;
+
+    //String, RaxenEntity
+    @Getter private HashMap<String, RaxenEntity> monster = new HashMap<>();
+
+    /**
+     * The Type of the Dungeon
+     */
+    @Getter private Types types;
+
+    /**
+     * Monster Types
+     */
+    @Getter private MonsterType monsterType;
+
+    @Getter private Location location;
+    @Getter private Integer radius;
+
+    public Dungeon(String name, Rank rank, Types types, MonsterType mType) {
+        this.name = name;
+        this.rank = rank;
+        this.types = types;
+        this.monsterType = mType;
+        generateGate();
+    }
+
+    /**
+     * Generate the Gate and make it available to players in the world.
+     * TODO: Place the gate at a random place.
+     */
+    public void generateGate() {
+        // -281.50 36.00 187.50
+        Location loc = new Location(Bukkit.getWorld("Liberty_City"), -284.0, 45.00, 187.50);
+        Integer radius = getRadiusFromRank(this.rank);
+        this.gate = new Gate(name, loc, radius);
+    }
+
+    /**
+     * TODO: Terrain Generation of the inside of the Dungeons
+     */
+    public void generate() {
+        Raxen main = (Raxen) Bukkit.getPluginManager().getPlugin("Raxen");
+        main.getManager().getWorldManager().loadWorld(name);
+        monsterType.genMonster(Bukkit.getWorld(name), rank);
+
+    }
+}

src/main/java/me/unurled/raxen/components/dungeons/Gate.java

@@ -0,0 +1,74 @@
+package me.unurled.raxen.components.dungeons;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+
+import java.util.Random;
+
+public class Gate {
+
+    private String name;
+
+    private Location loc;
+    private Integer portalRadius;
+
+
+    public Gate(String name, Location loc, Integer portalRadius) {
+        this.loc = loc;
+        this.portalRadius = portalRadius;
+        this.name = name;
+    }
+
+    public void teleport() {
+
+    }
+
+    public void genGate() {
+        // get which side it's gonna expand with radius
+        Random r = new Random();
+        Boolean xExpend = false;
+        if (r.nextInt(2) == 0) {
+            xExpend = true;
+        }
+
+        // place blocks
+        for (double i = 0; i <= Math.PI; i += Math.PI / portalRadius) {
+            double radius = Math.sin(i);
+            double y = Math.cos(i);
+            for (double a = 0; a < Math.PI * 2; a+= Math.PI / portalRadius) {
+                double x = Math.cos(a) * radius;
+                double z = Math.sin(a) * radius;
+                Location locc = new Location(loc.getWorld(), x, y, z);
+                loc.getBlock().setType(Material.NETHER_PORTAL);
+            }
+        }
+        /*
+        for (int n=0; n<portalRadius ; n++) {
+            Double x = loc.getX();
+            Double y = loc.getY();
+            Double z = loc.getZ();
+            if (xExpend) {
+                Location locc = new Location(loc.getWorld(), x + n, y + n, z);
+                locc.getBlock().setType(Material.NETHER_PORTAL);
+                locc = new Location(loc.getWorld(), loc.getX() - n, y-n, z);
+                locc.getBlock().setType(Material.NETHER_PORTAL);
+
+            }
+        }
+
+         */
+    }
+
+
+    public Location getLoc() {
+        return loc;
+    }
+
+    public Integer getPortalRadius() {
+        return portalRadius;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

src/main/java/me/unurled/raxen/components/dungeons/Rank.java

@@ -0,0 +1,16 @@
+package me.unurled.raxen.components.dungeons;
+
+public enum Rank {
+    F,
+    E,
+    D,
+    C,
+    B,
+    A,
+    S,
+    SS,
+    SSS,
+    WORLD,
+    UNBEATABLE,
+    NOT_DEFINED
+}

src/main/java/me/unurled/raxen/components/dungeons/Type.java

@@ -0,0 +1,19 @@
+package me.unurled.raxen.components.dungeons;
+
+import me.unurled.raxen.components.entity.other.RaxenEntity;
+import me.unurled.raxen.components.lootchest.loots.LootItem;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class Type {
+
+    public String name;
+
+    public Map<String, RaxenEntity> monster = new HashMap<>();
+
+    public Map<String, LootItem> lootItem = new HashMap<>();
+
+    // public Map<String, > chest
+
+}

src/main/java/me/unurled/raxen/components/dungeons/Types.java

@@ -0,0 +1,20 @@
+package me.unurled.raxen.components.dungeons;
+
+public enum Types {
+    JUNGLE,
+    TROPICAL_JUNGLE,
+    PLAINS,
+    GRAVES,
+    CASTLE,
+    ABANDONED_CASTLE,
+    FIELD,
+    ICE_FOREST,
+    FOREST,
+    VOLCANO,
+    MOUNTAINS,
+    HIGH_MOUNTAINS,
+    CAVES,
+    LABYRINTH,
+    UNDERGROUND_LABYRINTH,
+    FOREST_LABYRINTH
+}

src/main/java/me/unurled/raxen/components/dungeons/types/MonsterType.java

@@ -0,0 +1,94 @@
+package me.unurled.raxen.components.dungeons.types;
+
+import me.unurled.raxen.components.dungeons.Rank;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Random;
+
+import static me.unurled.raxen.utils.Utils.debug;
+
+public class MonsterType {
+    public enum type {;
+
+        private Double rate;
+        public String ID;
+        public Class clazz;
+
+        type(Double rate, String ID, Class clazz) {
+            this.rate = rate;
+            this.ID = ID;
+            this.clazz = clazz;
+        }
+
+        public static @Nullable type getTypeById(String ID) {
+            for (type type : type.values()) {
+                if(type.ID.equals(ID)) {
+                    return type;
+                }
+            }
+            return null;
+        }
+
+        public Double getRate() {
+            return rate;
+        }
+
+        public void setRate(Double rate) {
+            this.rate = rate;
+        }
+
+        public String getID() {
+            return ID;
+        }
+
+        public void setID(String ID) {
+            this.ID = ID;
+        }
+
+        public Class getClazz() {
+            return clazz;
+        }
+
+        public void getClazz(Class clazz) {
+            this.clazz = clazz;
+        }
+    }
+
+    public void genMonster(World world, Rank rank) {
+        Double x = 0.0;
+        Double y = 100.0;
+        Double z = 0.0;
+        for (type type : type.values()) {
+            type.name();
+            Random r = new Random();
+            int per = r.nextInt(100);
+            if (per >= type.rate) {
+                // spawn entity
+                debug("Spawning Entity " + type.ID);
+                Entity e = world.spawnEntity(new Location(world, x, y, z), EntityType.ARROW);
+                // e = ((RaxenEntity) type.getClazz()).createEntity();
+                e.setInvulnerable(true);
+                BukkitTask task = new BukkitRunnable() {
+                    @Override
+                    public void run() {
+                        Location loc = new Location(e.getWorld(), e.getLocation().getX(), e.getLocation().getY()-1, e.getLocation().getZ());
+                        if (loc.getBlock().getType() != Material.AIR) {
+                            e.setInvulnerable(false);
+                            this.cancel();
+                        }
+                    }
+                }.runTaskTimerAsynchronously(Bukkit.getPluginManager().getPlugin("Raxen"), 0L, 20L);
+            }
+            x = 5.0 + ( 50.0 - 5.0 ) * r.nextDouble();
+            z = 5.0 + ( 50.0 - 5.0 ) * r.nextDouble();
+        }
+    }
+}

src/main/java/me/unurled/raxen/components/dungeons/types/forest/ForestDungeon.java

@@ -0,0 +1,16 @@
+package me.unurled.raxen.components.dungeons.types.forest;
+
+import me.unurled.raxen.components.dungeons.Dungeon;
+import me.unurled.raxen.components.dungeons.Rank;
+import me.unurled.raxen.components.dungeons.Types;
+import me.unurled.raxen.components.dungeons.types.MonsterType;
+
+public class ForestDungeon extends Dungeon {
+    public ForestDungeon(String name, Rank rank, Types types, MonsterType mType) {
+        super(name, rank, types, mType);
+    }
+
+    public ForestDungeon() {
+        super("Forest", Rank.E, Types.FOREST, new ForestMonster());
+    }
+}

src/main/java/me/unurled/raxen/components/dungeons/types/forest/ForestMonster.java

@@ -0,0 +1,24 @@
+package me.unurled.raxen.components.dungeons.types.forest;
+
+import lombok.Getter;
+import me.unurled.raxen.components.dungeons.types.MonsterType;
+import me.unurled.raxen.components.entity.other.custom.dungeon.forest.Elf;
+import me.unurled.raxen.components.entity.other.custom.dungeon.forest.Wolf;
+
+public class ForestMonster extends MonsterType {
+
+    @Getter enum type {
+        ELF(50.0 ,"ELF", Elf.class),
+        WOLF(50.0, "WOLF", Wolf.class);
+
+        private Double rate;
+        public String ID;
+        public Class clazz;
+
+        type(Double rate, String ID, Class clazz) {
+            this.rate = rate;
+            this.ID = ID;
+            this.clazz = clazz;
+        }
+    }
+}

src/main/java/me/unurled/raxen/components/enchantments/EnchantmentWarpper.java

@@ -0,0 +1,103 @@
+package me.unurled.raxen.components.enchantments;
+
+import io.papermc.paper.enchantments.EnchantmentRarity;
+import net.kyori.adventure.key.Key;
+import net.kyori.adventure.text.Component;
+import org.bukkit.NamespacedKey;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.enchantments.EnchantmentTarget;
+import org.bukkit.entity.EntityCategory;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Set;
+
+public class EnchantmentWarpper extends Enchantment {
+    private final int maxLevel;
+
+    public EnchantmentWarpper(String nameSpace, String name, int lvl) {
+        super(NamespacedKey.minecraft(nameSpace));
+        this.maxLevel = lvl;
+    }
+
+    @Override @Deprecated
+    public @NotNull String getName() {
+        return null;
+    }
+
+    @Override
+    public int getMaxLevel() {
+        return maxLevel;
+    }
+
+    @Override
+    public int getStartLevel() {
+        return 0;
+    }
+
+    @Override
+    public @NotNull EnchantmentTarget getItemTarget() {
+        return null;
+    }
+
+    @Override
+    public boolean isTreasure() {
+        return false;
+    }
+
+    @Override
+    public boolean isCursed() {
+        return false;
+    }
+
+    @Override
+    public boolean conflictsWith(@NotNull Enchantment other) {
+        return false;
+    }
+
+    @Override
+    public boolean canEnchantItem(@NotNull ItemStack item) {
+        return false;
+    }
+
+    @Override
+    public @NotNull Component displayName(int level) {
+        return null;
+    }
+
+    @Override
+    public boolean isTradeable() {
+        return false;
+    }
+
+    @Override
+    public boolean isDiscoverable() {
+        return false;
+    }
+
+    @Override
+    public @NotNull EnchantmentRarity getRarity() {
+        return null;
+    }
+
+    @Override
+    public float getDamageIncrease(int level, @NotNull EntityCategory entityCategory) {
+        return 0;
+    }
+
+    @Override
+    public @NotNull Set<EquipmentSlot> getActiveSlots() {
+        return null;
+    }
+
+    @Override
+    public @NotNull String translationKey() {
+        return null;
+    }
+
+    @Override
+    public @NotNull Key key() {
+        return super.key();
+    }
+}

src/main/java/me/unurled/raxen/components/enchantments/player/Telekinesis.java

@@ -0,0 +1,10 @@
+package me.unurled.raxen.components.enchantments.player;
+
+import me.unurled.raxen.components.enchantments.EnchantmentWarpper;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.event.Listener;
+
+public class Telekinesis implements Listener {
+
+    public static final Enchantment TELEKINESIS = new EnchantmentWarpper("telekinesis", "telekinesis", 1);
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/Attribute.java

@@ -0,0 +1,126 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import de.tr7zw.nbtapi.NBTItem;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.inventory.EntityEquipment;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.persistence.PersistentDataType;
+import org.jetbrains.annotations.NotNull;
+
+import static me.unurled.raxen.utils.Utils.debug;
+
+public class Attribute {
+
+    /**
+     * The NamespaceKey register for the PersistentDataContainer.
+     * static NamespacedKey namespacekey = namespacedKey.TYPE;
+     */
+    public NamespacedKey namespacekey;
+
+    /**
+     * The name of the attribute
+     * static String name = "null";
+     */
+    public String name;
+
+    public Attribute(NamespacedKey namespacekey, String name) {
+        this.namespacekey = namespacekey;
+        this.name = name;
+    }
+
+    /**
+     * get how many the Entity has Attributed
+     * @param entity a living entity
+     * @return the amount of attribute
+     */
+    public Integer get(@NotNull Entity entity) {
+        if (entity.getPersistentDataContainer().has(namespacekey, PersistentDataType.INTEGER)) {
+            debug(" attribute gett" + entity.getPersistentDataContainer().get(namespacekey, PersistentDataType.INTEGER));
+            return entity.getPersistentDataContainer().get(namespacekey, PersistentDataType.INTEGER);
+        }
+        debug(name + " not found in Entity: " + entity.getType().toString() + " " + entity.getName() + " " + entity.getUniqueId().toString());
+        set(entity, 0);
+        return 0;
+    }
+
+    /**
+     * get how many the Entity has Attributed
+     * @param it an ItemStack
+     * @return the amount of attribute
+     */
+    public Integer get(@NotNull ItemStack it) {
+        NBTItem nbti = new NBTItem(it);
+        if (nbti.hasKey(name)){
+            return nbti.getInteger(name);
+        }
+        return 0;
+    }
+
+    /**
+     * Get the amount of attribute on the item
+     * @param e a LivingEntity
+     * @return an amount of attribute on the item
+     */
+    public Integer getItem(@NotNull LivingEntity e) {
+        EntityEquipment equi = e.getEquipment();
+        Integer attribute = 0;
+        if (equi != null) {
+            if (equi.getItemInMainHand().getType() != Material.AIR && equi.getHelmet() != null) {
+                ItemStack item = equi.getItemInMainHand();
+                attribute = attribute + get(item);
+            }
+            if (equi.getHelmet().getType() != Material.AIR && equi.getHelmet() != null) {
+                ItemStack item = equi.getHelmet();
+                attribute = attribute + get(item);
+            }
+            if (equi.getChestplate().getType() != Material.AIR && equi.getChestplate() != null) {
+                ItemStack item = equi.getChestplate();
+                attribute = attribute + get(item);
+            }
+            if (equi.getChestplate().getType() != Material.AIR && equi.getChestplate() != null) {
+                ItemStack item = equi.getChestplate();
+                attribute = attribute + get(item);
+            }
+            if (equi.getLeggings().getType() != Material.AIR && equi.getLeggings() != null) {
+                ItemStack item = equi.getLeggings();
+                attribute = attribute + get(item);
+            }
+            if (equi.getBoots().getType() != Material.AIR && equi.getBoots() != null) {
+                ItemStack item = equi.getBoots();
+                attribute = attribute + get(item);
+            }
+        }
+        return attribute;
+    }
+
+    /**
+     * set amount to the entity's attribute
+     * @param entity a living entity
+     * @param amount the amount you want to set
+     */
+    public void set(@NotNull Entity entity, @NotNull Integer amount) {
+        entity.getPersistentDataContainer().set(namespacekey, PersistentDataType.INTEGER, amount);
+        debug("set " + name + " " + amount);
+    }
+
+    /**
+     * add amount to the entity's attribute
+     * @param entity a living entity
+     * @param amount the amount you want to set
+     */
+    public void add(@NotNull Entity entity, @NotNull Integer amount) {
+        set(entity, get(entity) + amount);
+    }
+
+    /**
+     * remove amount to the entity's attribute
+     * @param entity a living entity
+     * @param amount the amount you want to set
+     */
+    public void remove(@NotNull Entity entity, @NotNull Integer amount) {
+        set(entity, get(entity) - amount);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/Defense.java

@@ -0,0 +1,11 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class Defense extends Attribute {
+
+    public Defense(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}
+

src/main/java/me/unurled/raxen/components/entity/Attributes/Health.java

@@ -0,0 +1,11 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class Health extends Attribute {
+
+    public Health(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}
+

src/main/java/me/unurled/raxen/components/entity/Attributes/ItemDefense.java

@@ -0,0 +1,10 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class ItemDefense extends Attribute {
+
+    public ItemDefense(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/ItemHealth.java

@@ -0,0 +1,10 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class ItemHealth extends Attribute {
+
+    public ItemHealth(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/ItemLuck.java

@@ -0,0 +1,10 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class ItemLuck extends Attribute {
+
+    public ItemLuck(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/ItemMana.java

@@ -0,0 +1,10 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class ItemMana extends Attribute {
+
+    public ItemMana(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/ItemSpeed.java

@@ -0,0 +1,10 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class ItemSpeed extends Attribute {
+
+    public ItemSpeed(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/ItemStrength.java

@@ -0,0 +1,10 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class ItemStrength extends Attribute {
+
+    public ItemStrength(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/Luck.java

@@ -0,0 +1,11 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class Luck extends Attribute {
+
+    public Luck(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}
+

src/main/java/me/unurled/raxen/components/entity/Attributes/Mana.java

@@ -0,0 +1,11 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class Mana extends Attribute {
+
+    public Mana(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}
+

src/main/java/me/unurled/raxen/components/entity/Attributes/MaxHealth.java

@@ -0,0 +1,10 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class MaxHealth extends Attribute {
+
+    public MaxHealth(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/MaxMana.java

@@ -0,0 +1,10 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class MaxMana extends Attribute {
+
+    public MaxMana(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/MaxManaBuilder.java

@@ -0,0 +1,22 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class MaxManaBuilder {
+    private NamespacedKey namespacekey;
+    private String name;
+
+    public MaxManaBuilder setNamespacekey(NamespacedKey namespacekey) {
+        this.namespacekey = namespacekey;
+        return this;
+    }
+
+    public MaxManaBuilder setName(String name) {
+        this.name = name;
+        return this;
+    }
+
+    public MaxMana createMaxMana() {
+        return new MaxMana(namespacekey, name);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/Speed.java

@@ -0,0 +1,10 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class Speed extends Attribute {
+
+    public Speed(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/Attributes/Strength.java

@@ -0,0 +1,11 @@
+package me.unurled.raxen.components.entity.Attributes;
+
+import org.bukkit.NamespacedKey;
+
+public class Strength extends Attribute {
+
+    public Strength(NamespacedKey namespacekey, String name) {
+        super(namespacekey, name);
+    }
+}
+

src/main/java/me/unurled/raxen/components/entity/other/EntityNamespacedKey.java

@@ -0,0 +1,49 @@
+package me.unurled.raxen.components.entity.other;
+
+import me.unurled.raxen.Raxen;
+import org.bukkit.NamespacedKey;
+
+public class EntityNamespacedKey {
+
+    public EntityNamespacedKey(Raxen main) {
+        name = new NamespacedKey(main, "NAME");
+        level = new NamespacedKey(main, "LEVEL");
+        maxHealth = new NamespacedKey(main, "MAX_HEALTH");
+        health = new NamespacedKey(main, "HEALTH");
+        itemHealth = new NamespacedKey(main, "ITEM_HEALTH");
+        speed = new NamespacedKey(main, "SPEED");
+        itemSpeed = new NamespacedKey(main, "ITEM_SPEED");
+        defense = new NamespacedKey(main, "DEFENSE");
+        itemDefense = new NamespacedKey(main, "ITEM_DEFENSE");
+        strength = new NamespacedKey(main, "STRENGTH");
+        itemStrength = new NamespacedKey(main, "ITEM_STRENGTH");
+        maxMana = new NamespacedKey(main, "MAX_MANA");
+        mana = new NamespacedKey(main, "MANA");
+        itemMana = new NamespacedKey(main, "ITEM_MANA");
+        luck = new NamespacedKey(main, "LUCK");
+        itemLuck = new NamespacedKey(main, "ITEM_LUCK");
+        inventory = new NamespacedKey(main, "INVENTORY");
+        storage = new NamespacedKey(main, "STORAGE");
+
+    }
+
+    public final NamespacedKey name;
+    public final NamespacedKey level;
+    public final NamespacedKey maxHealth;
+    public final NamespacedKey health;
+    public final NamespacedKey itemHealth;
+    public final NamespacedKey speed;
+    public final NamespacedKey itemSpeed;
+    public final NamespacedKey defense;
+    public final NamespacedKey itemDefense;
+    public final NamespacedKey strength;
+    public final NamespacedKey itemStrength;
+    public final NamespacedKey maxMana;
+    public final NamespacedKey mana;
+    public final NamespacedKey itemMana;
+    public final NamespacedKey luck;
+    public final NamespacedKey itemLuck;
+    public final NamespacedKey inventory;
+    public final NamespacedKey storage;
+
+}

src/main/java/me/unurled/raxen/components/entity/other/EntityUtils.java

@@ -0,0 +1,70 @@
+package me.unurled.raxen.components.entity.other;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+import org.jetbrains.annotations.NotNull;
+
+import static me.unurled.raxen.utils.Utils.debug;
+
+public class EntityUtils {
+
+    private static Raxen main;
+    private static EntityNamespacedKey namespacedKey;
+
+    public EntityUtils(Raxen main) {
+        this.main = main;
+        namespacedKey = new EntityNamespacedKey(main);
+    }
+
+    public static void setNameSpacedKeys(org.bukkit.entity.@NotNull Entity e, String name, Integer level, int health, int itemHealth, int defense, int itemDefense, int speed, int itemSpeed, int strength, int itemDmg) {
+        PersistentDataContainer data = e.getPersistentDataContainer();
+        data.set(namespacedKey.health, PersistentDataType.INTEGER, health);
+        data.set(namespacedKey.itemHealth, PersistentDataType.INTEGER, itemHealth);
+        data.set(namespacedKey.speed, PersistentDataType.INTEGER, speed);
+        data.set(namespacedKey.itemSpeed, PersistentDataType.INTEGER, itemSpeed);
+        data.set(namespacedKey.defense, PersistentDataType.INTEGER, defense);
+        data.set(namespacedKey.itemDefense, PersistentDataType.INTEGER, itemDefense);
+        data.set(namespacedKey.strength, PersistentDataType.INTEGER, strength);
+        data.set(namespacedKey.itemStrength, PersistentDataType.INTEGER, itemDmg);
+        data.set(namespacedKey.name, PersistentDataType.STRING, name);
+        data.set(namespacedKey.level, PersistentDataType.INTEGER, level);
+    }
+
+    public static void updateSkills(@NotNull LivingEntity livingEntity) {
+        PlayerManager pm = ((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager().getPlayerManager();
+        int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
+        defense= pm.getDefense().get(livingEntity);
+        maxMana = pm.getMaxMana().get(livingEntity);
+        itemDefense= pm.getItemDefense().get(livingEntity);
+        health = pm.getHealth().get(livingEntity);
+        itemHealth = pm.getItemHealth().get(livingEntity);
+        mana = pm.getMana().get(livingEntity);
+        speed = pm.getSpeed().get(livingEntity);
+        itemLuck = pm.getItemLuck().get(livingEntity);
+        strength = pm.getStrength().get(livingEntity);
+        luck = pm.getLuck().get(livingEntity);
+        maxHealth = pm.getMaxHealth().get(livingEntity);
+        itemStrength = pm.getItemStrength().get(livingEntity);
+        itemSpeed = pm.getItemSpeed().get(livingEntity);
+        itemMana = pm.getItemMana().get(livingEntity);
+        if (livingEntity.getAttribute(org.bukkit.attribute.Attribute.GENERIC_FLYING_SPEED) != null) {
+            livingEntity.getAttribute(org.bukkit.attribute.Attribute.GENERIC_FLYING_SPEED).setBaseValue((float) (0.0 + ((speed + itemSpeed) / 100) * 0.2));
+        }
+        if (livingEntity.getAttribute(org.bukkit.attribute.Attribute.GENERIC_MOVEMENT_SPEED) != null) {
+            livingEntity.getAttribute(org.bukkit.attribute.Attribute.GENERIC_MOVEMENT_SPEED).setBaseValue((float) (0.0 + ((speed + itemSpeed) / 100) * 0.2));
+        }
+        livingEntity.getAttribute(org.bukkit.attribute.Attribute.GENERIC_MAX_HEALTH).setBaseValue(20D + (health + itemHealth) / 100);
+        debug("Entity " + livingEntity.getType().name(),
+                "Speed " + (speed + itemSpeed),
+                "Health " + (health + itemHealth) + " Max Health " + maxHealth,
+                "Defense " + (defense+itemDefense),
+                "Strength " + (strength+itemStrength),
+                "Luck " + (luck+itemLuck),
+                "Mana " + (mana + itemMana) + " Max Mana " + maxMana);
+    }
+
+}

src/main/java/me/unurled/raxen/components/entity/other/RaxenEntity.java

@@ -0,0 +1,56 @@
+package me.unurled.raxen.components.entity.other;
+
+import lombok.Getter;
+import lombok.Setter;
+import me.unurled.raxen.Raxen;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Location;
+import org.bukkit.NamespacedKey;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+
+public abstract class RaxenEntity {
+
+    private final Raxen main;
+
+    @Getter private final String name;
+
+    @Getter private Integer level;
+
+    @Getter @Setter private Double health;
+
+    @Getter @Setter private Double strength;
+
+    @Getter @Setter Boolean isAlive = false;
+
+    public RaxenEntity(Raxen main, String name, Integer level, Double health, Double strength) {
+        this.main = main;
+        this.name = name;
+        this.level = level;
+        this.health = health;
+        this.strength = strength;
+    }
+
+    public Entity createEntity(EntityType types, String name, Location location) {
+        Entity e = location.getWorld().spawnEntity(location, types);
+        e.setCustomNameVisible(true);
+        e.customName(Component.text(name));
+
+        return e;
+    }
+
+    public void register(Entity e) {
+        PersistentDataContainer data  = e.getPersistentDataContainer();
+        data.set(new NamespacedKey(main ,"NAME"), PersistentDataType.STRING, name);
+    }
+
+    public Double getMaxHealth(Entity e) {
+        PersistentDataContainer data  = e.getPersistentDataContainer();
+        EntityNamespacedKey key = new EntityNamespacedKey(main);
+        return data.get(key.maxHealth, PersistentDataType.DOUBLE);
+    }
+
+    public abstract Entity createEntity(Location location);
+}

src/main/java/me/unurled/raxen/components/entity/other/custom/Entity.java

@@ -0,0 +1,68 @@
+package me.unurled.raxen.components.entity.other.custom;
+
+import lombok.Getter;
+import lombok.Setter;
+import me.unurled.raxen.Raxen;
+
+import static me.unurled.raxen.utils.Utils.colorString;
+
+public class Entity {
+
+    private final String name;
+    @Getter
+    private Integer level;
+    @Setter
+    private Double health;
+    @Getter
+    @Setter
+    private Double strength;
+    @Getter
+    @Setter
+    private Double defense;
+    @Getter
+    @Setter
+    private Double speed;
+    @Getter
+    @Setter
+    private Double maxHealth;
+    @Getter
+    @Setter
+    private boolean isHostile;
+
+    public Entity(String name, Integer level, Double maxHealth, Double strength, Double defense, Double speed, boolean isHostile) {
+        this.name = name;
+        this.level = level;
+        this.health = maxHealth;
+        this.strength = strength;
+        this.defense = defense;
+        this.speed = speed;
+        this.maxHealth = maxHealth;
+        this.isHostile = isHostile;
+    }
+
+    public void register (Raxen main) {
+        main.getManager().getEntityManager().entities.put(name, this);
+    }
+
+    public String getName() {
+        return "<white>" + name;
+    }
+
+    public String getFullName(Entity e) {
+        if (isHostile) {
+            return colorString(getColorLevel() + "<white>⚔️" + getName() + "<red>" + health + "<white>/<white/>" + maxHealth);
+        } else {
+            return colorString(getColorLevel() + "<white>❤️" + getName() + "<red>" + health + "<white>/<white/>" + maxHealth);
+        }
+    }
+
+    public String getColorLevel() {
+        return level.toString();
+    }
+
+    public Double getHealth() {
+        Double health = 0.0;
+
+        return health;
+    }
+}

src/main/java/me/unurled/raxen/components/entity/other/custom/dungeon/forest/Elf.java

@@ -0,0 +1,34 @@
+package me.unurled.raxen.components.entity.other.custom.dungeon.forest;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.other.RaxenEntity;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+
+public class Elf extends RaxenEntity {
+
+    @Getter private final String name;
+
+    public Elf(Raxen main, String name, Integer level, Double health, Double strength) {
+        super(main, name, level, health, strength);
+        this.name = name;
+    }
+
+    @Override
+    public Entity createEntity(Location location) {
+        return super.createEntity(EntityType.PLAYER, name, location);
+    }
+
+    /**
+     * Elf Default values
+     * @param main the main instance
+     * @param name
+     */
+    public Elf(Raxen main, String name) {
+        super(main, "Elf", 10, 120.0, 25.0);
+        this.name = name;
+    }
+
+}

src/main/java/me/unurled/raxen/components/entity/other/custom/dungeon/forest/Wolf.java

@@ -0,0 +1,29 @@
+package me.unurled.raxen.components.entity.other.custom.dungeon.forest;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.other.RaxenEntity;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+
+public class Wolf extends RaxenEntity {
+
+    @Getter private final String name;
+
+
+    public Wolf(Raxen main, String name, Integer level, Double health, Double strength) {
+        super(main, name, level, health, strength);
+        this.name = name;
+    }
+
+    public Wolf(Raxen main) {
+        super(main, "Wolf", 5, 100.0, 20.0);
+        this.name = "Wolf";
+    }
+
+    @Override
+    public Entity createEntity(Location location) {
+        return super.createEntity(EntityType.WOLF, name, location);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/other/custom/hostile/low/Goblin.java

@@ -0,0 +1,31 @@
+package me.unurled.raxen.components.entity.other.custom.hostile.low;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.other.RaxenEntity;
+import me.unurled.raxen.components.entity.other.custom.Entity;
+import org.bukkit.Location;
+import org.bukkit.entity.EntityType;
+
+public class Goblin extends Entity {
+
+    RaxenEntity goblin;
+
+    public Goblin(Raxen main) {
+        super("Goblin", 1, 100.0, 10.0, 0.0, 50.0, true);
+        this.goblin = new RaxenEntity(main, "Goblin", 1, 100.0, 10.0) {
+            @Override
+            public org.bukkit.entity.Entity createEntity(Location location) {
+                return super.createEntity(EntityType.PLAYER, "Goblin", location);
+            }
+        };
+        register(main);
+    }
+
+    public String getName() {
+        return "<white>" + goblin.getName();
+    }
+
+    public String getFullName(Entity e) {
+        return "<white>⚔️" + getName() + "<red>" + getHealth() + "<white>/<white/>" + getMaxHealth();
+    }
+}

src/main/java/me/unurled/raxen/components/entity/other/spawn/Eggs.java

@@ -0,0 +1,4 @@
+package me.unurled.raxen.components.entity.other.spawn;
+
+public class Eggs {
+}

src/main/java/me/unurled/raxen/components/entity/player/Inventories.java

@@ -0,0 +1,19 @@
+package me.unurled.raxen.components.entity.player;
+
+import me.unurled.raxen.components.entity.player.storages.Inventory;
+
+public class Inventories {
+    private Inventory inv;
+
+    public Inventories(Inventory inv) {
+        this.inv = inv;
+    }
+
+    public Inventory getInv() {
+        return inv;
+    }
+
+    public void setInv(Inventory inv) {
+        this.inv = inv;
+    }
+}

src/main/java/me/unurled/raxen/components/entity/player/PlayerUtils.java

@@ -0,0 +1,42 @@
+package me.unurled.raxen.components.entity.player;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.Bukkit;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.entity.Player;
+
+import static me.unurled.raxen.utils.Utils.debug;
+
+public class PlayerUtils {
+
+    public static void updateSkills(Raxen main, Player player) {
+        PlayerManager pm = ((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager().getPlayerManager();
+        int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
+        defense= pm.getDefense().get(player);
+        maxMana = pm.getMaxMana().get(player);
+        itemDefense= pm.getItemDefense().get(player);
+        health = pm.getHealth().get(player);
+        itemHealth = pm.getItemHealth().get(player);
+        mana = pm.getMana().get(player);
+        speed = pm.getSpeed().get(player);
+        itemLuck = pm.getItemLuck().get(player);
+        strength = pm.getStrength().get(player);
+        luck = pm.getLuck().get(player);
+        maxHealth = pm.getMaxHealth().get(player);
+        itemStrength = pm.getItemStrength().get(player);
+        itemSpeed = pm.getItemSpeed().get(player);
+        itemMana = pm.getItemMana().get(player);
+        player.getAttribute(Attribute.GENERIC_MAX_HEALTH).setBaseValue(20D + (health + itemHealth) / 100);
+        player.setWalkSpeed((float) (0.0 + ((speed + itemSpeed) / 100) * 0.2));
+        player.setFlySpeed((float) (0.0 + ((speed + itemSpeed) / 100) * 0.2));
+        debug("Player " + player.getName(),
+                "Speed " + (speed + itemSpeed),
+                "Health " + (health + itemHealth) + " Max Health " + maxHealth,
+                "Defense " + (defense+itemDefense),
+                "Strength " + (strength+itemStrength),
+                "Luck " + (luck+itemLuck),
+                "Mana " + (mana + itemMana) + " Max Mana " + maxMana);
+    }
+
+}

src/main/java/me/unurled/raxen/components/entity/player/RaxenPlayer.java

@@ -0,0 +1,131 @@
+package me.unurled.raxen.components.entity.player;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.other.EntityNamespacedKey;
+import me.unurled.raxen.components.entity.player.attributes.Attribute;
+import me.unurled.raxen.components.entity.player.storages.EnderChest;
+import me.unurled.raxen.components.entity.player.storages.Inventory;
+import me.unurled.raxen.utils.EntityAttributes;
+import me.unurled.raxen.utils.Items;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static me.unurled.raxen.utils.Items.setItemsToInventory;
+import static me.unurled.raxen.utils.Utils.debug;
+
+public class RaxenPlayer {
+
+    private final Raxen main;
+    private final Player player;
+    private final EntityNamespacedKey namespacedKey;
+
+    private Boolean isRaxenPlayer;
+
+    private Attribute attribute;
+
+    private Storage storages;
+    private Inventories inventory;
+
+    public RaxenPlayer(Raxen main, Player player) {
+        this.main = main;
+        this.player = player;
+        this.namespacedKey = new EntityNamespacedKey(main);
+        this.isRaxenPlayer = true;
+    }
+
+    public Attribute createNewAttribute() {
+        debug(main, "Created new Attribute");
+        EntityAttributes.setAttributes(player, 100, 100,0,50,0,100,0,100,0, 100, 100, 0, 10, 0);
+        return new Attribute(100,100,0,50,0,100,0,100,0, 100, 100, 0, 10, 0);
+    }
+
+    public void setStorages(org.bukkit.inventory.Inventory inv, org.bukkit.inventory.Inventory ec) {
+        setStorage(ec);
+        setInventory(inv);
+    }
+
+    public Storage getStorage() {
+        PersistentDataContainer data = player.getPersistentDataContainer();
+        String store = data.get(namespacedKey.storage, PersistentDataType.STRING);
+        org.bukkit.inventory.Inventory ec = Bukkit.createInventory(null, 54, Component.text("Ender Chest"));
+        ec = setItemsToInventory(Items.mapItemStackDeserialize(store), ec);
+        EnderChest ecc = new EnderChest(ec);
+        Storage storage = new Storage(ecc);
+        return storage;
+    }
+
+    public Inventories getInventory() {
+        PersistentDataContainer data = player.getPersistentDataContainer();
+        String inv = data.get(namespacedKey.inventory, PersistentDataType.STRING);
+        org.bukkit.inventory.Inventory invv = Bukkit.createInventory(player, InventoryType.PLAYER);
+        PlayerInventory invvvvv = (PlayerInventory) Bukkit.createInventory(null, InventoryType.PLAYER);
+        invv = setItemsToInventory(Items.listItemStackDeserialize(inv), invvvvv);
+        Inventory invvv = new Inventory(invv);
+        Inventories invvvv = new Inventories(invvv);
+        return invvvv;
+    }
+
+    public void setInventory(org.bukkit.inventory.Inventory inv) {
+        PersistentDataContainer data = player.getPersistentDataContainer();
+        List<String> listInv = new ArrayList<String>();
+        Integer reverse = 0;
+        for(ItemStack it : inv) {
+            reverse = reverse + 1;
+            if(it != null && it.getType() != Material.AIR) {
+                String s = Items.itemStackSerialize(it, reverse);
+                listInv.add(s);
+            }
+        }
+        String invv = Items.listItemStackSerialize(listInv);
+        this.inventory = new Inventories(new Inventory(inv));
+        data.set(namespacedKey.inventory, PersistentDataType.STRING, invv);
+    }
+
+    public void setStorage(org.bukkit.inventory.Inventory ec) {
+        PersistentDataContainer data = player.getPersistentDataContainer();
+        List<String> list = new ArrayList<String>();
+        int reverse = 0;
+        for(ItemStack it : ec) {
+            if(it != null) {
+                String s = Items.itemStackSerialize(it, reverse);
+                list.add(s);
+            }
+            reverse += 1;
+        }
+        String store = Items.listItemStackSerialize(list);
+        this.storages = new Storage(new EnderChest(ec));
+        data.set(namespacedKey.storage, PersistentDataType.STRING, store);
+    }
+
+    public Storage createStorage() {
+        setStorage(Bukkit.createInventory(null, 54, Component.text("Ender Chest")));
+        return getStorage();
+    }
+
+    public Inventories createInventory() {
+        setInventory(Bukkit.createInventory(null, InventoryType.PLAYER));
+        return getInventory();
+    }
+
+    public Boolean isRaxenPlayer() {
+        return isRaxenPlayer;
+    }
+
+    public void isRaxenPlayer(boolean player) {
+        isRaxenPlayer = player;
+    }
+
+    public Attribute getAttribute() {
+        return attribute;
+    }
+}

src/main/java/me/unurled/raxen/components/entity/player/Scoreboard.java

@@ -0,0 +1,57 @@
+package me.unurled.raxen.components.entity.player;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.utils.libs.Vault;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.scoreboard.DisplaySlot;
+import org.bukkit.scoreboard.Objective;
+import org.bukkit.scoreboard.Score;
+import org.bukkit.scoreboard.ScoreboardManager;
+
+import static me.unurled.raxen.utils.Utils.*;
+
+public class Scoreboard {
+
+    private Raxen main;
+    private Vault vault;
+
+    public Scoreboard(Raxen main) {
+        this.main = main;
+        this.vault = main.getManager().getLibsManager().getVault();
+    }
+
+    public void createScorebord(Player player) {
+        ScoreboardManager manager = Bukkit.getScoreboardManager();
+        org.bukkit.scoreboard.Scoreboard board = manager.getNewScoreboard();
+        Objective obj = board.registerNewObjective("Raxen","dummy", colorTextComp("<red>Elixium"));
+        obj.setDisplaySlot(DisplaySlot.SIDEBAR);
+        Score score = obj.getScore(colorString("<gold>-------------"));
+        score.setScore(4);
+        Score score1 = obj.getScore(colorString("<aqua>Name:" + player.getName()));
+        score1.setScore(3);
+        Score score2 = obj.getScore(colorString("<white>Location"));
+        score2.setScore(2);
+        Score score3 = obj.getScore(colorString("<gold>Coins: <gold>" + vault.getBalanceString(player)));
+        score3.setScore(1);
+        Score score4 = obj.getScore(colorString("<yellow>unurled.me"));
+        score4.setScore(0);
+        player.setScoreboard(board);
+    }
+
+    public void updateScoreboardTransaction(Player player) {
+        if(player != null) {
+            Objective objective = player.getScoreboard().getObjective(DisplaySlot.SIDEBAR);
+            player.getScoreboard().getObjective(DisplaySlot.SIDEBAR);
+            debug(main, String.valueOf(player.getScoreboard().getEntries()));
+            for (String str : player.getScoreboard().getEntries()) {
+                if(str.contains(player.getName())) {
+
+                }
+            }
+            player.getScoreboard().resetScores("Coins");
+            Score score = objective.getScore(colorString("<gold>Coins: <gold>" + vault.getBalanceString(player)));
+            score.setScore(1);
+        }
+    }
+}

src/main/java/me/unurled/raxen/components/entity/player/Storage.java

@@ -0,0 +1,20 @@
+package me.unurled.raxen.components.entity.player;
+
+import me.unurled.raxen.components.entity.player.storages.EnderChest;
+
+public class Storage {
+
+    private EnderChest ec;
+
+    public Storage(EnderChest ec) {
+        this.ec = ec;
+    }
+
+    public EnderChest getEc() {
+        return ec;
+    }
+
+    public void setEc(EnderChest ec) {
+        this.ec = ec;
+    }
+}

src/main/java/me/unurled/raxen/components/entity/player/attributes/Attribute.java

@@ -0,0 +1,28 @@
+package me.unurled.raxen.components.entity.player.attributes;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class Attribute {
+
+    @Getter
+    @Setter
+    private int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
+
+    public Attribute(int maxHealth, int health, int itemHealth, int defense, int itemDefense, int speed, int itemSpeed, int strength, int itemStrength, int maxMana, int mana, int itemMana, int luck, int itemLuck) {
+        this.maxHealth = maxHealth;
+        this.health = health;
+        this.itemHealth = itemHealth;
+        this.defense = defense;
+        this.itemDefense = itemDefense;
+        this.speed = speed;
+        this.itemSpeed = itemSpeed;
+        this.strength = strength;
+        this.itemStrength = itemStrength;
+        this.maxHealth = maxMana;
+        this.mana = mana;
+        this.itemMana = itemMana;
+        this.luck = luck;
+        this.itemLuck = itemLuck;
+    }
+}

src/main/java/me/unurled/raxen/components/entity/player/attributes/Attributes.java

@@ -0,0 +1,57 @@
+package me.unurled.raxen.components.entity.player.attributes;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.other.EntityNamespacedKey;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+public class Attributes {
+
+    private static EntityNamespacedKey namespacedKey;
+
+    public Attributes(Raxen main) {
+        namespacedKey = new EntityNamespacedKey(main);
+    }
+
+    public static Attribute getAttribute(Player player) {
+        int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
+        PlayerManager pm = ((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager().getPlayerManager();
+        Entity e = player;
+        defense= pm.getDefense().get(e);
+        maxMana = pm.getMaxMana().get(e);
+        itemDefense= pm.getItemDefense().get(e);
+        health = pm.getHealth().get(e);
+        itemHealth = pm.getItemHealth().get(e);
+        mana = pm.getMana().get(e);
+        speed = pm.getSpeed().get(e);
+        itemLuck = pm.getItemLuck().get(e);
+        strength = pm.getStrength().get(e);
+        luck = pm.getLuck().get(e);
+        maxHealth = pm.getMaxHealth().get(e);
+        itemStrength = pm.getItemStrength().get(e);
+        itemSpeed = pm.getItemSpeed().get(e);
+        itemMana = pm.getItemMana().get(e);
+        return new Attribute(maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck);
+    }
+
+    public static void setAttributes(Player player, int maxHealth, int health, int itemHealth, int defense, int itemDefense, int speed, int itemSpeed, int strength, int itemStrength, int maxMana, int mana, int itemMana, int luck, int itemLuck) {
+        PlayerManager pm = ((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager().getPlayerManager();
+        Entity e = player;
+        pm.getDefense().set(e, defense);
+        pm.getMaxMana().set(e, maxMana);
+        pm.getItemDefense().set(e, itemDefense);
+        pm.getHealth().set(e, health);
+        pm.getItemHealth().set(e, itemHealth);
+        pm.getMana().set(e, mana);
+        pm.getSpeed().set(e, speed);
+        pm.getItemLuck().set(e, itemLuck);
+        pm.getStrength().set(e, strength);
+        pm.getLuck().set(e, luck);
+        pm.getMaxHealth().set(e, maxHealth);
+        pm.getItemStrength().set(e, itemStrength);
+        pm.getItemSpeed().set(e, itemSpeed);
+        pm.getItemMana().set(e, itemMana);
+    }
+}

src/main/java/me/unurled/raxen/components/entity/player/classes/Class.java

@@ -0,0 +1,29 @@
+package me.unurled.raxen.components.entity.player.classes;
+
+import lombok.Getter;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+import static me.unurled.raxen.utils.Utils.colorTextComp;
+
+public class Class {
+
+    @Getter
+    String name;
+    @Getter
+    String colorName;
+    @Getter
+    String ID;
+    @Getter
+    ItemStack placeHolder;
+    @Getter
+    Integer max_level;
+
+    public Class(String name, String colorName, String ID, String itemPlaceHolder, Integer max_level) {
+        this.name = name;
+        this.ID = ID;
+        this.placeHolder = new ItemStack(Material.getMaterial(itemPlaceHolder));
+        this.placeHolder.getItemMeta().displayName(colorTextComp(colorName));
+        this.max_level = max_level;
+    }
+}

src/main/java/me/unurled/raxen/components/entity/player/classes/Classes.java

@@ -0,0 +1,87 @@
+package me.unurled.raxen.components.entity.player.classes;
+
+import lombok.Getter;
+import lombok.Setter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+
+import static me.unurled.raxen.utils.Utils.debug;
+import static me.unurled.raxen.utils.Utils.error;
+
+public class Classes {
+
+    private final Raxen main;
+    @Getter
+    private HashMap<String, Class> classes = new HashMap<>();
+
+    public Classes(Raxen main) {
+        this.main = main;
+    }
+
+    public void register() {
+        File folder = new File(main.getDataFolder() + "/Class/");
+        File[] listFile = folder.listFiles();
+        PlayerManager pm = main.getManager().getPlayerManager();
+        for (int i = 0; i < listFile.length; i++) {
+            if (listFile[i].isFile()) {
+                FileConfiguration customClass = new YamlConfiguration();
+                try {
+                    customClass.load(listFile[i]);
+                } catch (IOException | InvalidConfigurationException e) {
+                    e.printStackTrace();
+                }
+                resultClass cla = registerClass(customClass);
+                pm.addClasses(cla.getClas(), cla.getId());
+            } else if (listFile[i].isDirectory()) {
+                for (int a = 0; a < listFile[i].listFiles().length; a++) {
+                    if(listFile[i].listFiles()[a].isFile()) {
+                        FileConfiguration customClass = new YamlConfiguration();
+                        try {
+                            customClass.load(listFile[i].listFiles()[a]);
+                        } catch (IOException | InvalidConfigurationException e) {
+                            e.printStackTrace();
+                        }
+                        resultClass cla = registerClass(customClass);
+                        pm.addClasses(cla.getClas(), cla.getId());
+                    } else if (listFile[i].listFiles()[a].isDirectory()) {
+                        error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),"Can't use more than 2 folder to get Class.yml");
+                    }
+
+                }
+            }
+        }
+    }
+
+    public class resultClass {
+        @Getter
+        @Setter
+        public Class clas;
+        @Getter
+        @Setter
+        public String id;
+        public resultClass(Class clas, String id) {
+            this.clas = clas;
+            this.id = id;
+        }
+    }
+
+    public resultClass registerClass(FileConfiguration file) {
+        String id = file.getString("id");
+        debug(id);
+        return new resultClass(new Class(file.getString("name"), file.getString("color-name"), id, file.getString("item_placeholder"), file.getInt("max_level")), id);
+    }
+
+    public void registerClass(Class clas) {
+        debug(clas.getID());
+        resultClass result = new resultClass(clas, clas.getID());
+        classes.put(result.getId(), result.getClas());
+    }
+}

src/main/java/me/unurled/raxen/components/entity/player/classes/list/Assassin.java

@@ -0,0 +1,19 @@
+package me.unurled.raxen.components.entity.player.classes.list;
+
+import me.unurled.raxen.components.items.custom.weapon.Dager;
+import org.bukkit.inventory.ItemStack;
+
+public class Assassin {
+    String ID = "ASSASSIN";
+    String name = "Assassin";
+    String colorName = "<red>Assassin";
+    Integer max_level = 100;
+
+    ItemStack placeHolder;
+
+    public Assassin() {
+        Dager dager = new Dager();
+        dager.buildItem();
+        placeHolder = dager.getDager();
+    }
+}

src/main/java/me/unurled/raxen/components/entity/player/storages/EnderChest.java

@@ -0,0 +1,18 @@
+package me.unurled.raxen.components.entity.player.storages;
+
+import lombok.Getter;
+import lombok.Setter;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.inventory.Inventory;
+
+public class EnderChest {
+
+    @Getter
+    @Setter
+    public Inventory ec = Bukkit.createInventory(null, 54, Component.text("Ender Chest"));
+
+    public EnderChest(Inventory ec) {
+        this.ec = ec;
+    }
+}

src/main/java/me/unurled/raxen/components/entity/player/storages/Inventory.java

@@ -0,0 +1,16 @@
+package me.unurled.raxen.components.entity.player.storages;
+
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.Bukkit;
+import org.bukkit.event.inventory.InventoryType;
+
+public class Inventory {
+    @Getter
+    @Setter
+    public org.bukkit.inventory.Inventory inv =  Bukkit.createInventory(null, InventoryType.PLAYER);
+
+    public Inventory(org.bukkit.inventory.Inventory inv) {
+        this.inv = inv;
+    }
+}

src/main/java/me/unurled/raxen/components/gui/ItemListGui.java

@@ -0,0 +1,224 @@
+package me.unurled.raxen.components.gui;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.player.PlayerUtils;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+import static me.unurled.raxen.utils.Items.*;
+import static me.unurled.raxen.utils.Utils.fillGreyPane;
+import static me.unurled.raxen.utils.Utils.log;
+
+public class ItemListGui implements Listener {
+
+    private Raxen main;
+    @Getter
+    private Inventory inv = Bukkit.createInventory(null, 54, Component.text("Item List"));
+    private Inventory inv2 = Bukkit.createInventory(null, 54, Component.text("Item List"));
+    private Inventory inv3 = Bukkit.createInventory(null, 54, Component.text("Item List"));
+    private Inventory inv4 = Bukkit.createInventory(null, 54, Component.text("Item List"));
+    private Inventory inv5 = Bukkit.createInventory(null, 54, Component.text("Item List"));
+    private Inventory inv6 = Bukkit.createInventory(null, 54, Component.text("Item List"));
+    private Inventory inv7 = Bukkit.createInventory(null, 54, Component.text("Item List"));
+    private Inventory inv8 = Bukkit.createInventory(null, 54, Component.text("Item List"));
+    private Inventory inv9 = Bukkit.createInventory(null, 54, Component.text("Item List"));
+
+    private HashMap<String, ItemStack> itlist;
+
+    public ItemListGui(Raxen main) {
+        this.main = main;
+        this.itlist = this.main.getManager().getItemManager().getList();
+        this.inv = getInventories();
+    }
+
+    private ItemStack PREVIOUS = createItem(Material.ARROW, 1,true, false, "Previous page");
+    private ItemStack NEXT = createItem(Material.ARROW, 1,true, false, "Next page");
+    private ItemStack PAGE = createItem(Material.PAPER, 1,true, false, "Page");
+    private ItemStack CLOSE = closeItem();
+    private ItemStack GREY_PANE = greyPane();
+
+    public Inventory getInventories() {
+        Integer page = 1;
+        Integer item = -1;
+        for (Map.Entry<String, ItemStack> entry : itlist.entrySet()) {
+            ItemStack it = entry.getValue();
+            item++;
+            if(item > 44 && item < 91) {
+                inv2.addItem(it);
+                inv2.setItem(48, PREVIOUS);
+                inv2.setItem(49, editItem(PAGE, "page" + page,1, new ArrayList<Component>()));
+                inv2.setItem(53, CLOSE);
+                inv2 = fillGreyPane(inv2);
+            }
+            if (item > 90 && item < 136) {
+                inv3.setItem(48, PREVIOUS);
+                inv3.setItem(49, editItem(PAGE, "page" + page,1, new ArrayList<Component>()));
+                inv3.setItem(53, CLOSE);
+                inv3 = fillGreyPane(inv3);
+            }
+            if (item > 135 && item < 181) {
+                inv4.addItem(it);
+                inv4.setItem(48, PREVIOUS);
+                inv4.setItem(49, editItem(PAGE, "page" + page,1, new ArrayList<Component>()));
+                inv4.setItem(53, CLOSE);
+                inv4 = fillGreyPane(inv4);
+            }
+            if (item > 180 && item < 226) {
+                inv5.addItem(it);
+                inv5.setItem(48, PREVIOUS);
+                inv5.setItem(49, editItem(PAGE, "page" + page,1, new ArrayList<Component>()));
+                inv5.setItem(53, CLOSE);
+                inv5 = fillGreyPane(inv5);
+            }
+            if (item > 225 && item < 271) {
+                inv6.addItem(it);
+                inv6.setItem(48, PREVIOUS);
+                inv6.setItem(49, editItem(PAGE, "page" + page,1, new ArrayList<Component>()));
+                inv6.setItem(53, CLOSE);
+                inv6 = fillGreyPane(inv6);
+            }
+            if (item > 270 && item < 316) {
+                inv7.addItem(it);
+                inv7.setItem(48, PREVIOUS);
+                inv7.setItem(49, editItem(PAGE, "page" + page,1, new ArrayList<Component>()));
+                inv7.setItem(53, CLOSE);
+                inv7 = fillGreyPane(inv7);
+            }
+            if (item > 315 && item < 361) {
+                inv8.addItem(it);
+                inv8.setItem(48, PREVIOUS);
+                inv8.setItem(49, editItem(PAGE, "page" + page,1, new ArrayList<Component>()));
+                inv8.setItem(53, CLOSE);
+                inv8 = fillGreyPane(inv8);
+            }
+            if (item > 360 && item < 406) {
+                inv9.addItem(it);
+                inv9.setItem(48, PREVIOUS);
+                inv9.setItem(49, editItem(PAGE, "page" + page,1, new ArrayList<Component>()));
+                inv9.setItem(53, CLOSE);
+                inv9 = fillGreyPane(inv9);
+            }
+            if (item > 405) {
+                log("Too many item to render.");
+            }
+            else {
+                inv.addItem(it);
+                inv.setItem(49, PAGE);
+                inv.setItem(50, NEXT);
+            }
+            if (item > 44) {
+                inv.setItem(50, NEXT);
+                if (item > 90) {
+                    inv2.setItem(50, NEXT);
+                    if (item > 135) {
+                        inv3.setItem(50, NEXT);
+                        if (item > 180) {
+                            inv4.setItem(50, NEXT);
+                            if (item > 225) {
+                                inv5.setItem(50, NEXT);
+                                if (item > 270) {
+                                    inv6.setItem(50, NEXT);
+                                    if (item > 315) {
+                                        inv7.setItem(50, NEXT);
+                                        if (item > 360) {
+                                            inv8.setItem(50, NEXT);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            page++;
+            inv.setItem(53, CLOSE);
+            inv = fillGreyPane(inv);
+        }
+        return inv;
+    }
+
+    @EventHandler
+    public void clickInventory(InventoryClickEvent e) {
+        Player player = (Player) e.getWhoClicked();
+        Inventory einv = e.getClickedInventory();
+        if (einv == inv || einv == inv2 || einv == inv3 ||
+                einv == inv4 || einv == inv5 || einv == inv6 ||
+                einv == inv7 || einv == inv8 || einv == inv9) {
+            if(e.getCurrentItem() != null && e.getCurrentItem().getType() != Material.AIR) {
+                Integer slot = e.getSlot();
+                ItemStack clicked;
+                if (slot ==48) {
+                    //previous
+                    if (e.getCurrentItem() != GREY_PANE) {
+                        ItemStack pagee = einv.getItem(49);
+                        Integer page = Integer.parseInt(pagee.displayName().toString().replace("page", ""));
+                        switch(page) {
+                            case 2:
+                                player.openInventory(inv);
+                            case 3:
+                                player.openInventory(inv2);
+                            case 4:
+                                player.openInventory(inv3);
+                            case 5:
+                                player.openInventory(inv4);
+                            case 6:
+                                player.openInventory(inv5);
+                            case 7:
+                                player.openInventory(inv6);
+                            case 8:
+                                player.openInventory(inv7);
+                            case 9:
+                                player.openInventory(inv8);
+                        }
+                    }
+                } else if  (slot == 49) {
+                    //page
+                    return;
+                } else if (slot == 50) {
+                    //next
+                    ItemStack pagee = einv.getItem(49);
+                    Integer page = Integer.parseInt(pagee.displayName().toString().replace("page", ""));
+                    switch(page) {
+                        case 1:
+                            player.openInventory(inv2);
+                        case 2:
+                            player.openInventory(inv3);
+                        case 3:
+                            player.openInventory(inv4);
+                        case 4:
+                            player.openInventory(inv5);
+                        case 5:
+                            player.openInventory(inv6);
+                        case 6:
+                            player.openInventory(inv7);
+                        case 7:
+                            player.openInventory(inv8);
+                        case 8:
+                            player.openInventory(inv9);
+                    }
+                }  else if (slot == 53) {
+                    //close
+                    player.closeInventory();
+                } else {
+                    //if (player.getInventory().firstEmpty() == -1) {
+                        //add to stash
+                    //}
+                    player.getInventory().addItem(e.getCurrentItem());
+                    PlayerUtils.updateSkills(main, player);
+                }
+            }
+        }
+    }
+}

src/main/java/me/unurled/raxen/components/gui/MainGui.java

@@ -0,0 +1,71 @@
+package me.unurled.raxen.components.gui;
+
+import me.unurled.raxen.utils.Items;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.SkullMeta;
+
+import java.util.HashMap;
+
+import static me.unurled.raxen.utils.Utils.colorComp;
+import static me.unurled.raxen.utils.Utils.fillGreyPane;
+
+public class MainGui {
+
+    public static Inventory build(Player p) {
+        Inventory inv = Bukkit.createInventory(null, 54, colorComp("<dark_grey>Raxen</dark_grey>"));
+        String gui = "0,7,0,0,0,8,9,0,10," +
+                     "0,0,0,0,0,0,0,0,0," +
+                     "0,0,0,0,0,0,0,0,0," +
+                     "0,2,3,0,0,0,0,4,0," +
+                     "0,0,0,0,1,0,0,0,0," +
+                     "0,0,0,0,0,0,0,0,0";
+        // 1 player Head
+        ItemStack head = new ItemStack(Material.PLAYER_HEAD);
+        SkullMeta headm = (SkullMeta) head.getItemMeta();
+        headm.setOwningPlayer(p.getPlayer());
+        headm.displayName(colorComp("<green></green>"));
+        // 2 bank
+        ItemStack bank = new ItemStack(Material.GOLD_INGOT);
+        // 3 ah
+        ItemStack ah = new ItemStack(Material.GOLD_INGOT);
+        // 4 skill tree
+        ItemStack sk_tree = new ItemStack(Material.OAK_SAPLING);
+        // 7 teleport
+        ItemStack tp = new ItemStack(Material.ENDER_PEARL);
+        // 8 select character
+        ItemStack sel_char = new ItemStack(Material.SNOWBALL);
+        // 9 Settings
+        ItemStack sett = new ItemStack(Material.MAGMA_CREAM);
+        // 10 barrier block close
+
+        HashMap<String, ItemStack> list = new HashMap<>();
+        list.put("1", head);
+        list.put("2", bank);
+        list.put("3",ah);
+        list.put("4", sk_tree);
+        list.put("7", tp);
+        list.put("8", sel_char);
+        list.put("9", sett);
+        list.put("10", Items.closeItem());
+        Inventory inventory = stringToGui(inv, gui,list);
+        inventory = fillGreyPane(inventory);
+        return inventory;
+    }
+
+    public static Inventory stringToGui(Inventory inv, String stt, HashMap<String, ItemStack> it) {
+        String[] s = stt.split(",");
+        if (s.length != inv.getContents().length) {
+            return inv;
+        }
+        Integer i = 0;
+        for (String st : s) {
+            inv.setItem(i, it.get(st));
+            i++;
+        }
+        return inv;
+    }
+}

src/main/java/me/unurled/raxen/components/items/Attributes.java

@@ -0,0 +1,15 @@
+package me.unurled.raxen.components.items;
+
+import lombok.Getter;
+
+public class Attributes {
+    @Getter
+    Integer health, speed, defense, strength;
+
+    public Attributes(Integer health, Integer defense, Integer speed, Integer strength, Integer mana, Integer luck) {
+        this.health = health;
+        this.defense = defense;
+        this.speed = speed;
+        this.strength = strength;
+    }
+}

src/main/java/me/unurled/raxen/components/items/CustomModelData.java

@@ -0,0 +1,4 @@
+package me.unurled.raxen.components.items;
+
+public class CustomModelData {
+}

src/main/java/me/unurled/raxen/components/items/NBT.java

@@ -0,0 +1,15 @@
+package me.unurled.raxen.components.items;
+
+public class NBT {
+
+    public static String HEALTH = "HEALTH";
+    public static String SPEED = "SPEED";
+    public static String STRENGTH = "STRENGTH";
+    public static String DEFENSE = "DEFENSE";
+    public static String LUCK = "LUCK";
+    public static String MANA = "MANA";
+    public static String ID = "ID";
+    public static String CUSTOM_ABILITY = "CUSTOM_ABILITY";
+    public static String DROP_RATE = "DROP_RATE";
+
+}

src/main/java/me/unurled/raxen/components/items/custom/Item.java

@@ -0,0 +1,11 @@
+package me.unurled.raxen.components.items.custom;
+
+import me.unurled.raxen.Raxen;
+
+public interface Item {
+
+    public void buildItem();
+
+    public void registerItem(Raxen main);
+
+}

src/main/java/me/unurled/raxen/components/items/custom/List.java

@@ -0,0 +1,26 @@
+package me.unurled.raxen.components.items.custom;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.items.custom.weapon.Dager;
+
+import java.util.ArrayList;
+
+public class List {
+
+    private static Raxen main;
+
+    @Getter
+    private java.util.List<Item> items;
+
+    public List(Raxen main) {
+        this.main = main;
+        this.items = new ArrayList<>();
+
+    }
+
+    public void build() {
+        // weapons
+        items.add(new Dager());
+    }
+}

src/main/java/me/unurled/raxen/components/items/custom/weapon/Dager.java

@@ -0,0 +1,51 @@
+package me.unurled.raxen.components.items.custom.weapon;
+
+import de.tr7zw.nbtapi.NBTItem;
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.items.custom.Item;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Material;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemFlag;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static me.unurled.raxen.components.items.NBT.*;
+import static me.unurled.raxen.utils.Utils.colorTextComp;
+
+public class Dager implements Item {
+    @Getter
+    ItemStack dager;
+
+    public void buildItem() {
+        dager = new ItemStack(Material.IRON_SWORD);
+        ItemMeta itm = dager.getItemMeta();
+        itm.displayName(colorTextComp("<aqua>Dager"));
+        itm.addEnchant(Enchantment.PROTECTION_ENVIRONMENTAL, 1, false);
+        itm.addItemFlags(ItemFlag.HIDE_ATTRIBUTES, ItemFlag.HIDE_ENCHANTS);
+        itm.setUnbreakable(true);
+        List<Component> lore = new ArrayList<>();
+        lore.add(Component.text("hallooo"));
+        itm.lore(lore);
+        dager.setItemMeta(itm);
+        NBTItem nbti = new NBTItem(dager);
+        nbti.setString(ID, "DAGER");
+        nbti.setInteger(SPEED, 100);
+        nbti.setInteger(STRENGTH, 50);
+        nbti.setString(CUSTOM_ABILITY, "throwing_dager");
+        nbti.setDouble(DROP_RATE, 50.0);
+        dager = nbti.getItem();
+    }
+
+    /**
+     * need Raxen main to be set before calling this method.
+     */
+    @Override
+    public void registerItem(Raxen main) {
+        main.getManager().getItemManager().registerItem(dager);
+    }
+}

src/main/java/me/unurled/raxen/components/lootchest/GUI.java

@@ -0,0 +1,24 @@
+package me.unurled.raxen.components.lootchest;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+
+public class GUI {
+    @Getter
+    private static Inventory inv =  Bukkit.createInventory(null, 54);
+    private static PlayerManager playerManager;
+
+    public GUI(Raxen main) {
+        this.playerManager = main.getManager().getPlayerManager();
+    }
+
+    public static Inventory addItems(Player player) {
+        Integer luck = playerManager.getLuck().get(player);
+
+        return inv;
+    }
+}

src/main/java/me/unurled/raxen/components/lootchest/loots/CustomLoot.java

@@ -0,0 +1,43 @@
+package me.unurled.raxen.components.lootchest.loots;
+
+import de.tr7zw.nbtapi.NBTItem;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.items.NBT;
+import org.bukkit.Location;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.HashMap;
+
+public class CustomLoot {
+
+    private Raxen main;
+
+    public HashMap<String, ItemStack> itlist;
+
+    public ItemStack item;
+    public Double drop_rate;
+    public LootItem lootItem;
+    public String ID;
+
+    public LootItem getLootItem() {
+        return new LootItem(registerItem(), drop_rate);
+    }
+
+    public ItemStack registerItem() {
+        return itlist.get(ID);
+    }
+
+    public Double getDrop_rate() {
+        NBTItem nbti = new NBTItem(item);
+        if (nbti.hasKey(NBT.DROP_RATE)) {
+            return nbti.getDouble(NBT.DROP_RATE);
+        }
+        return 0.0;
+    }
+
+    public void tryDropLoot(Location location) {
+        for (LootItem item : main.getManager().getLootManager().getLootTable()) {
+            item.tryDropItem(location);
+        }
+    }
+}

src/main/java/me/unurled/raxen/components/lootchest/loots/LootItem.java

@@ -0,0 +1,29 @@
+package me.unurled.raxen.components.lootchest.loots;
+
+import org.bukkit.Location;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Random;
+
+public class LootItem {
+
+    private ItemStack item;
+    private int min = 1, max = 1;
+    private double dropRate;
+    private static Random randomiser = new Random();
+
+
+    public LootItem(ItemStack item, double dropRate) {
+        this.item = item;
+        this.dropRate = dropRate;
+    }
+
+    public void tryDropItem(Location loc) {
+        if (Math.random() * 101 > dropRate) return;
+        int amount = randomiser.nextInt(max - min + 1) + min;
+        if (amount == 0) return;
+        ItemStack item = this.item.clone();
+        item.setAmount(amount);
+        loc.getWorld().dropItemNaturally(loc, item);
+    }
+}

src/main/java/me/unurled/raxen/components/lootchest/loots/test/TestSword.java

@@ -0,0 +1,15 @@
+package me.unurled.raxen.components.lootchest.loots.test;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.lootchest.loots.CustomLoot;
+
+public class TestSword extends CustomLoot {
+
+    public TestSword(Raxen main) {
+        this.itlist = main.getManager().getItemManager().getList();
+        this.ID = "BEST_NEW_ITEM";
+        this.drop_rate = getDrop_rate();
+        this.item = registerItem();
+        this.lootItem = getLootItem();
+    }
+}

src/main/java/me/unurled/raxen/components/resourcepack/ResourcePack.java

@@ -0,0 +1,31 @@
+package me.unurled.raxen.components.resourcepack;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.manager.server.ResourcePackManager;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+
+public class ResourcePack {
+
+    private Raxen main;
+    private FileConfiguration config;
+    private ResourcePackManager resourcePackManager;
+
+    public ResourcePack(Raxen main, ResourcePackManager manager) {
+        this.main = main;
+        this.config = main.getConfig();
+        this.resourcePackManager = manager;
+    }
+
+    public void join(Player player) {
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                if(resourcePackManager.isUseRP()) {
+                    player.setResourcePack(config.getString("ressource_pack_url"), config.getString("resource_pack_sha1"));
+                }
+            }
+        }.runTaskLater(main, 2L);
+    }
+}

src/main/java/me/unurled/raxen/config/Config.java

@@ -0,0 +1,51 @@
+package me.unurled.raxen.config;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+
+import static me.unurled.raxen.utils.Utils.debug;
+
+public class Config {
+    private Raxen main;
+
+    private File configFile;
+
+    @Getter
+    private FileConfiguration config;
+
+
+    public Config(Raxen main) {
+        this.main = main;
+        this.config = main.getConfig();
+        this.init();
+    }
+
+    /**
+     * init method, saves config and everything
+     */
+    public void init() {
+        FileConfiguration config = main.getConfig();
+        File configFile = new File(main.getDataFolder() + "/config.yml");
+        if (!(configFile.exists())) {
+            main.saveDefaultConfig();
+        }
+        FileConfiguration conf = new YamlConfiguration();
+        debug(main, config.getString("version"));
+        try {
+            conf.load(configFile);
+        } catch (IOException | InvalidConfigurationException e) {
+            e.printStackTrace();
+        }
+        debug(main, conf.getString("version"));
+        if(!Raxen.getVersion().equals(config.getString("version"))){
+            main.saveResource("config.yml", true);
+        }
+    }
+
+}

src/main/java/me/unurled/raxen/config/PlayerConfig.java

@@ -0,0 +1,286 @@
+package me.unurled.raxen.config;
+
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.model.Filters;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.Attributes.Attribute;
+import me.unurled.raxen.components.entity.player.Inventories;
+import me.unurled.raxen.components.entity.player.PlayerUtils;
+import me.unurled.raxen.components.entity.player.Storage;
+import me.unurled.raxen.components.entity.player.attributes.Attributes;
+import me.unurled.raxen.components.entity.player.storages.EnderChest;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import me.unurled.raxen.manager.entity.StorageManager;
+import me.unurled.raxen.utils.Items;
+import me.unurled.raxen.utils.libs.MongoDB;
+import net.kyori.adventure.text.Component;
+import org.bson.Document;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import static me.unurled.raxen.utils.Items.*;
+import static me.unurled.raxen.utils.Utils.debug;
+
+public class PlayerConfig {
+
+    private static Raxen main;
+    private MongoDB mongoDB;
+    private MongoCollection<Document> mongoCollection;
+    private static PlayerManager playerManager;
+    private static StorageManager sto;
+    private Attributes attributes;
+
+    public PlayerConfig(Raxen main) {
+        this.main = main;
+        sto = main.getManager().getStorageManager();
+        this.mongoDB = main.getManager().getLibsManager().getMongoDB();
+        this.mongoCollection = mongoDB.getMongoCollection();
+        playerManager = main.getManager().getPlayerManager();
+        this.attributes = new Attributes(main);
+    }
+
+    /**
+     * closes mongo connection
+     */
+    public void close()  {
+        mongoDB.close();
+    }
+
+    /**
+     * save players stuff to mongo db
+     * @param player
+     * @param attributes
+     * @param invstr
+     * @param reverse
+     */
+    public void saveUsingMongoDB(@NotNull Player player, Attributes attributes, String invstr, Integer reverse) {
+        debug(main, "Saving " + player.getName() + "'s data!");
+        Document doc = new Document("uuid", player.getUniqueId().toString())
+                .append("name", player.getName())
+                .append("inv", invstr);
+        HashMap<String, Attribute> attribute = main.getManager().getPlayerManager().getAttribute();
+        for (String s : attribute.keySet()) {
+            debug("saving " + s);
+            doc.append(s, attribute.get(s).get(player));
+        }
+        if (playerManager.getRaxenPlayer(player).getStorage() != null) {
+            if(playerManager.getRaxenPlayer(player).getStorage().getEc() != null) {
+                debug(main, "Saving " + player.getName() + "'s storage!");
+                EnderChest ec = playerManager.getRaxenPlayer(player).getStorage().getEc();
+                List<String> list = new ArrayList<String>();
+                reverse = 0;
+                for(ItemStack it : ec.getEc()) {
+                    if(it != null && it.getType() != Material.AIR) {
+                        String s = Items.itemStackSerialize(it, reverse);
+                        list.add(s);
+                    }
+                    reverse += 1;
+                }
+                String ecstr = Items.listItemStackSerialize(list);
+                doc.append("ec", ecstr);
+            }
+        }
+        Document playerDoc = mongoCollection.find(Filters.eq("uuid", player.getUniqueId().toString())).first();
+        if(playerDoc == null) {
+            mongoCollection.insertOne(doc);
+            debug(main, "insert one");
+        }
+        else {
+            mongoCollection.replaceOne(Filters.eq("uuid", player.getUniqueId().toString()), doc);
+            debug(main, "replace one");
+        }
+    }
+
+    /**
+     * save players stuff to yml
+     * @param player
+     * @param attributes
+     * @param invstr
+     * @param reverse
+     */
+    public void saveUsingYml(Player player, Attributes attributes, String invstr, Integer reverse) {
+        FileConfiguration config = sto.createYml(player);
+        config.set("name", player.getName());
+        HashMap<String, Attribute> attribute = main.getManager().getPlayerManager().getAttribute();
+        for (String s : attribute.keySet()) {
+            config.set(s, attribute.get(s).get(player));
+        }
+        config.set("inv", invstr);
+        if (playerManager.getRaxenPlayer(player).getStorage() != null) {
+            if(playerManager.getRaxenPlayer(player).getStorage().getEc() != null) {
+                EnderChest ec = playerManager.getRaxenPlayer(player).getStorage().getEc();
+                List<String> list = new ArrayList<String>();
+                reverse = 0;
+                for(ItemStack it : ec.getEc()) {
+                    reverse += 1;
+                    if(it != null) {
+                        String s = Items.itemStackSerialize(it, reverse);
+                        list.add(s);
+                    }
+                }
+                String ecstr = Items.listItemStackSerialize(list);
+                config.set("ec", ecstr);
+            }
+        }
+        try {
+            config.save(main.getDataFolder() + "/playerInfo/" + player.getUniqueId() + "/" + "playerInfo.yml");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * load player stuff from mongo db
+     * @param player
+     */
+    public void loadUsingMongoDB(@NotNull Player player) {
+        Document playerDoc = mongoCollection.find(Filters.eq("uuid", player.getUniqueId().toString())).first();
+        if(playerDoc == null) {
+            debug(main, "Intiatilising Data for Player: " + player.getName());
+            playerManager.getRaxenPlayer(player).createNewAttribute();
+            playerManager.getRaxenPlayer(player).createStorage();
+            playerManager.getRaxenPlayer(player).createInventory();
+            PlayerUtils.updateSkills(main, player);
+            return;
+        }
+        debug(main, "Loading " + player.getName() + "'s data!");
+        attributes.setAttributes(player, playerDoc.getInteger("MAX_HEALTH"), playerDoc.getInteger("HEALTH"), playerDoc.getInteger("ITEM_HEALTH"),
+                playerDoc.getInteger("DEFENSE"), playerDoc.getInteger("ITEM_DEFENSE"),
+                playerDoc.getInteger("SPEED"), playerDoc.getInteger("ITEM_SPEED"),
+                playerDoc.getInteger("STRENGTH"), playerDoc.getInteger("ITEM_STRENGTH"),
+                playerDoc.getInteger("MAX_MANA"), playerDoc.getInteger("MANA"), playerDoc.getInteger("ITEM_MANA"),
+                playerDoc.getInteger("LUCK"), playerDoc.getInteger("ITEM_LUCK"));
+        Inventory ec = Bukkit.createInventory(null, 54, Component.text("Ender Chest"));
+        if(playerDoc.getString("ec") != null) {
+            debug(main, "Loading " + player.getName() + "'s storage.");
+            ec = setItemsToInventory(mapItemStackDeserialize(playerDoc.getString("ec")), ec);
+        }
+        playerManager.getRaxenPlayer(player).setStorage(ec);
+        PlayerInventory inv = player.getInventory();
+        inv = setItemsToInventory(listItemStackDeserialize(playerDoc.getString("inv")), inv);
+        player.getInventory().setContents(inv.getContents());
+        player.updateInventory();
+        me.unurled.raxen.components.entity.player.storages.Inventory invv = new me.unurled.raxen.components.entity.player.storages.Inventory(inv);
+        Inventories invvv = new Inventories(invv);
+        playerManager.getRaxenPlayer(player).setInventory(inv);
+        PlayerUtils.updateSkills(main, player);
+    }
+
+    /**
+     * load player stuff from yml
+     * @param player
+     * @throws IOException
+     */
+    public void loadUsingYml(Player player) throws IOException {
+        FileConfiguration config = sto.createYml(player);
+        attributes.setAttributes(player, config.getInt("maxHealth"), config.getInt("health"), config.getInt("itemHealth"),
+                config.getInt("defense"), config.getInt("itemDefense"),
+                config.getInt("speed"), config.getInt("itemSpeed"),
+                config.getInt("strength"), config.getInt("itemStrength"),
+                config.getInt("maxMana"), config.getInt("mana"), config.getInt("itemMana"),
+                config.getInt("luck"), config.getInt("itemLuck"));
+        Inventory ec = Bukkit.createInventory(null, 54, Component.text("Ender Chest"));
+        if((String) config.get("ec") != null) {
+            ec = setItemsToInventory(mapItemStackDeserialize((String) config.get("ec")), ec);
+        }
+        EnderChest ecc = new EnderChest(ec);
+        Storage storage = new Storage(ecc);
+        playerManager.getRaxenPlayer(player).setStorage(ec);
+        PlayerInventory inv = (PlayerInventory) Bukkit.createInventory(player, InventoryType.PLAYER);
+        inv = setItemsToInventory(listItemStackDeserialize((String) config.getString("inv")), inv);
+        player.getInventory().setContents(inv.getContents());
+        player.updateInventory();
+        me.unurled.raxen.components.entity.player.storages.Inventory invv = new me.unurled.raxen.components.entity.player.storages.Inventory(inv);
+        Inventories invvv = new Inventories(invv);
+        playerManager.getRaxenPlayer(player).setInventory(inv);
+    }
+
+    /**
+     * saves player stuff
+     * @param player
+     */
+    public void savePlayerConfig(@NotNull Player player) {
+        Attributes attributes = new Attributes(main);
+        PlayerInventory inv = player.getInventory();
+
+        List<String> listInv = new ArrayList<String>();
+        Integer reverse = 0;
+        for(ItemStack it : inv) {
+            reverse = reverse + 1;
+            if(it != null && it.getType() != Material.AIR) {
+                String s = Items.itemStackSerialize(it, reverse);
+                listInv.add(s);
+            }
+        }
+        String invstr= Items.itemStackSer(inv);
+        debug(main, "saving...");
+        String storage = sto.getConfig().getString("storage");
+        Integer finalReverse = reverse;
+        String finalInvstr = invstr;
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                saveUsingMongoDB(player, attributes, finalInvstr, finalReverse);
+            }
+        }.runTaskAsynchronously(main);
+        debug(main, "using mongo");
+        if (storage == "MYSQL" || storage == "YML") {
+            String finalInvstr1 = invstr;
+            Integer finalReverse1 = reverse;
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    saveUsingYml(player, attributes, finalInvstr1, finalReverse1);
+                }
+            }.runTaskAsynchronously(main);
+            debug(main, "using yml");
+        }
+
+        debug(main, "Player: " + player.getName() + " data successfully saved!");
+    }
+
+    /**
+     * load player stuff
+     * @param player
+     */
+    public void loadPlayerConfig(Player player) {
+        String st = StorageManager.getConfig().getString("storage");
+        String value = "";
+        if (st.equals("MONGODB")) {
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    loadUsingMongoDB(player);
+                }
+            }.runTaskAsynchronously(main);
+            value = "mongodb";
+        } else {
+            value = "yml";
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    try {
+                        loadUsingYml(player);
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }.runTaskAsynchronously(main);
+        }
+        debug(main, "Player: " + player.getName() + " data successfully loaded using " + value);
+    }
+
+}

src/main/java/me/unurled/raxen/listener/entity/DamageEntity.java

@@ -0,0 +1,131 @@
+package me.unurled.raxen.listener.entity;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.other.EntityNamespacedKey;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.Bukkit;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByBlockEvent;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+
+import static me.unurled.raxen.utils.Utils.debug;
+
+public class DamageEntity implements Listener {
+
+    private Raxen main;
+    private EntityNamespacedKey entityNamespacedKey;
+
+    public DamageEntity(Raxen main) {
+        this.main = main;
+        this.entityNamespacedKey = new EntityNamespacedKey(main);
+    }
+
+    /**
+     * fired when an entity is damaged by another entity
+     * calculates the damage and apply it to the entity
+     * @param e
+     */
+    @EventHandler
+    public void entityDamageByEntity(EntityDamageByEntityEvent e) {
+        if (!(e.getEntity() instanceof LivingEntity) || !(e.getDamager() instanceof LivingEntity)) {
+            debug("Not Living Entity, Some block falling shit or block entities");
+        } else {
+            e.setDamage(0);
+            Integer damage = 1;
+            Integer strength = 0;
+            Integer itemStrength = 0;
+            Integer defense = 0;
+            Integer itemDefense = 0;
+            Integer health = 0;
+            Integer itemHealth = 0;
+            Integer initDamage = 0;
+            PlayerManager pm = ((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager().getPlayerManager();
+            debug(main, e.getEntity().getName(), e.getEntity().getType().toString(), e.getDamager().getType().toString(), e.getDamager().getName());
+            if (e.getDamager() instanceof Player) {
+                Player playerDamager = (Player) e.getDamager();
+                strength = pm.getStrength().get(playerDamager);
+                itemStrength = pm.getItemStrength().get(playerDamager);
+            } else {
+                Entity entityDamager = e.getDamager();
+                PersistentDataContainer data = entityDamager.getPersistentDataContainer();
+                if (data.has(entityNamespacedKey.strength, PersistentDataType.INTEGER)) {
+                    strength = data.get(entityNamespacedKey.strength, PersistentDataType.INTEGER);
+                }
+                itemStrength = pm.getItemStrength().getItem((LivingEntity) entityDamager);
+            }
+            if (e.getEntity() instanceof Player) {
+                Player playerVictim = (Player) e.getEntity();
+                me.unurled.raxen.components.entity.player.attributes.Attributes attributes = new me.unurled.raxen.components.entity.player.attributes.Attributes(main);
+                defense = pm.getDefense().get(playerVictim);
+                health = pm.getHealth().get(playerVictim);
+                itemDefense = pm.getItemDefense().get(playerVictim);
+                itemHealth = pm.getItemHealth().get(playerVictim);
+            } else {
+                Entity entityVictim = e.getEntity();
+                PersistentDataContainer data = entityVictim.getPersistentDataContainer();
+                if (data.has(entityNamespacedKey.defense, PersistentDataType.INTEGER)) {
+                    defense = data.get(entityNamespacedKey.defense, PersistentDataType.INTEGER);
+                }
+                if (data.has(entityNamespacedKey.health, PersistentDataType.INTEGER)) {
+                    health = data.get(entityNamespacedKey.health, PersistentDataType.INTEGER);
+                }
+                itemDefense = pm.getItemDefense().getItem((LivingEntity) entityVictim);
+                itemHealth = pm.getItemHealth().getItem((LivingEntity) entityVictim);
+            }
+            debug(main, initDamage.toString(), itemDefense.toString(), strength.toString());
+            initDamage = (5+ itemStrength) * (1+ (strength/100));
+            damage = initDamage;
+            defense = defense + itemDefense;
+            debug(main, String.valueOf(damage));
+            defense = defense/(defense+100);
+            debug(main, String.valueOf(damage));
+            debug(main, String.valueOf(defense));
+            Integer health_with_defense = health * (1+ (defense/100));
+            debug(main, String.valueOf(damage));
+            debug(main, String.valueOf(health));
+            debug(main, String.valueOf(health_with_defense));
+            if (damage >= health_with_defense) {
+                debug(main, "Killed entity normally.");
+                e.setDamage(e.getEntity().getType().getDefaultAttributes().getAttribute(Attribute.GENERIC_MAX_HEALTH).getDefaultValue());
+            } else {
+                debug(main, "Applying damage to entity.");
+                if (defense == 0) {
+                    health = health_with_defense - damage;
+                } else {
+                    health = health_with_defense - health - damage;
+                }
+                if (e.getEntity() instanceof Player) {
+                    Player playerVictim = (Player) e.getEntity();
+                    me.unurled.raxen.components.entity.player.attributes.Attributes attributes = new me.unurled.raxen.components.entity.player.attributes.Attributes(main);
+                    pm.getHealth().set(playerVictim, health);
+                    playerVictim.setHealth(health.doubleValue()/5);
+                } else {
+                    Entity entityVictim = e.getEntity();
+                    pm.getHealth().set(entityVictim, health);
+                }
+                debug(main, health.toString());
+            }
+        }
+    }
+
+    /**
+     * damage made by blocks on entity
+     * @param e
+     */
+    @EventHandler
+    public void entityDamageByBlock(EntityDamageByBlockEvent e) {
+        e.setDamage(0);
+        if (e.getEntity() instanceof Player) {
+            Player player = (Player) e.getEntity();
+
+
+        }
+    }
+}

src/main/java/me/unurled/raxen/listener/entity/SpawnEvent.java

@@ -0,0 +1,46 @@
+package me.unurled.raxen.listener.entity;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.other.EntityNamespacedKey;
+import me.unurled.raxen.components.entity.other.EntityUtils;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntitySpawnEvent;
+import org.bukkit.persistence.PersistentDataType;
+
+import static me.unurled.raxen.utils.Utils.debug;
+
+public class SpawnEvent implements Listener {
+
+    private Raxen main;
+    private EntityUtils entityUtils;
+    private EntityNamespacedKey namespacedKey;
+
+    public SpawnEvent(Raxen main) {
+        this.main = main;
+        this.entityUtils = new EntityUtils(main);
+        this.namespacedKey = new EntityNamespacedKey(main);
+    }
+
+    /**
+     * when a new entity spawns
+     * adds all persistent data container
+     * @param e
+     */
+    @EventHandler
+    public void Spawn(EntitySpawnEvent e) {
+        if (e.getEntity() instanceof Player) {
+            //player stuff dont want to talk about it; already doing it in player join event
+            debug(main, "Player: " + ((Player) e.getEntity()).getName());
+        } else if (e.getEntity().getType() != EntityType.DROPPED_ITEM && e.getEntity().getType() != EntityType.FALLING_BLOCK) {
+            debug(main, e.getEntity().getName());
+            if (!e.getEntity().getPersistentDataContainer().has(namespacedKey.name, PersistentDataType.STRING)) {
+                entityUtils.setNameSpacedKeys(e.getEntity(), e.getEntityType().name(), 1, 10, 0, 50, 0, 100, 0, 100, 0);
+            }
+            entityUtils.updateSkills((LivingEntity) e.getEntity());
+        }
+    }
+}

src/main/java/me/unurled/raxen/listener/player/ArmorEvent.java

@@ -0,0 +1,72 @@
+package me.unurled.raxen.listener.player;
+
+import com.destroystokyo.paper.event.player.PlayerArmorChangeEvent;
+import de.tr7zw.nbtapi.NBTItem;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.player.PlayerUtils;
+import me.unurled.raxen.components.entity.player.attributes.Attributes;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.inventory.ItemStack;
+
+public class ArmorEvent implements Listener {
+
+    private Raxen main;
+
+    public ArmorEvent(Raxen main) {
+        this.main = main;
+    }
+
+    /**
+     * when player changes armor, calculates new stats for player and setting it
+     * @param e
+     */
+    @EventHandler
+    public void ArmorChangeEvent(PlayerArmorChangeEvent e) {
+        Player player = e.getPlayer();
+        PlayerManager pm = ((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager().getPlayerManager();
+        Entity entity = player;
+        Attributes attributes = new Attributes(main);
+        if(e.getOldItem() != null && e.getOldItem().getType() != Material.AIR) {
+            ItemStack oldItem = e.getOldItem();
+            NBTItem nbti = new NBTItem(oldItem);
+            if(nbti.hasKey("SPEED")) {
+                pm.getSpeed().remove(entity, nbti.getInteger("SPEED"));
+            }
+            if(nbti.hasKey("HEALTH")) {
+                pm.getHealth().remove(entity, nbti.getInteger("HEALTH"));
+            }
+            if(nbti.hasKey("DEFENSE")) {
+                pm.getDefense().remove(entity, nbti.getInteger("DEFENSE"));
+
+            }
+            if(nbti.hasKey("STRENGTH")) {
+                pm.getStrength().remove(entity, nbti.getInteger("STRENGTH"));
+            }
+        }
+        if(e.getNewItem() != null && e.getNewItem().getType() != Material.AIR) {
+            ItemStack newItem = e.getNewItem();
+            NBTItem nbti = new NBTItem(newItem);
+            if(nbti.hasKey("SPEED")) {
+                pm.getSpeed().add(entity, nbti.getInteger("SPEED"));
+            }
+            if(nbti.hasKey("HEALTH")) {
+                pm.getHealth().add(entity, nbti.getInteger("HEALTH"));
+
+            }
+            if(nbti.hasKey("DEFENSE")) {
+                pm.getDefense().add(entity, nbti.getInteger("DEFENSE"));
+
+            }
+            if(nbti.hasKey("STRENGTH")) {
+                pm.getStrength().add(entity, nbti.getInteger("STRENGTH"));
+            }
+        }
+        PlayerUtils.updateSkills(main, player);
+    }
+}

src/main/java/me/unurled/raxen/listener/player/ClickBlockEvent.java

@@ -0,0 +1,43 @@
+package me.unurled.raxen.listener.player;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.lootchest.GUI;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+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;
+
+public class ClickBlockEvent implements Listener {
+
+    private Raxen main;
+    private GUI gui;
+
+    public ClickBlockEvent(Raxen main) {
+        this.main = main;
+        this.gui = new GUI(main);
+    }
+
+    /**
+     * use with guis
+     * @param e
+     */
+    @EventHandler
+    public void ClickEvent(PlayerInteractEvent e) {
+        Player player = e.getPlayer();
+        Block block = e.getClickedBlock();
+        Action action = e.getAction();
+        if (action.isRightClick()) {
+            if (block != null) {
+                if (block.getType() == Material.CHEST) {
+                    player.closeInventory();
+                    Inventory inv = gui.addItems(player);
+                    player.openInventory(inv);
+                }
+            }
+        }
+    }
+}

src/main/java/me/unurled/raxen/listener/player/CloseInventoryEvent.java

@@ -0,0 +1,32 @@
+package me.unurled.raxen.listener.player;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+
+import static me.unurled.raxen.utils.Utils.log;
+
+public class CloseInventoryEvent implements Listener {
+
+    private PlayerManager playerManager;
+
+    /**
+     * save enderchest/storage when player close
+     * @param e
+     */
+    @EventHandler
+    public void InventoryCloseEvent(InventoryCloseEvent e) {
+        Player player = (Player) e.getPlayer();
+        Component title = e.getView().title();
+        if (title.toString().contains("Ender Chest")) {
+            playerManager = ((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager().getPlayerManager();
+            playerManager.getRaxenPlayer(player).setStorage(e.getInventory());
+        }
+        log(player.getName() + " " + title.toString());
+    }
+}

src/main/java/me/unurled/raxen/listener/player/ItemHandEvent.java

@@ -0,0 +1,75 @@
+package me.unurled.raxen.listener.player;
+
+import de.tr7zw.nbtapi.NBTItem;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.player.PlayerUtils;
+import me.unurled.raxen.components.entity.player.attributes.Attributes;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerItemHeldEvent;
+import org.bukkit.inventory.ItemStack;
+
+public class ItemHandEvent implements Listener {
+
+    private Raxen main;
+
+    public ItemHandEvent(Raxen main) {
+        this.main = main;
+    }
+
+    /**
+     * when player have something in hand, change and add new stats
+     * @param e
+     */
+    @EventHandler
+    public void ItemHeldEvent(PlayerItemHeldEvent e) {
+        Player player = e.getPlayer();
+        PlayerManager pm = ((Raxen) Bukkit.getPluginManager().getPlugin("Raxen")).getManager().getPlayerManager();
+        Entity entity = player;
+        Attributes attributes = new Attributes(main);
+        ItemStack oldItem = player.getInventory().getItem(e.getPreviousSlot());
+        ItemStack newItem = player.getInventory().getItem(e.getNewSlot());
+        if(oldItem != null && oldItem.getType() != Material.AIR) {
+            NBTItem nbti = new NBTItem(oldItem);
+            if(nbti.hasKey("SPEED")) {
+                pm.getItemSpeed().remove(player, nbti.getInteger("SPEED"));
+            }
+            if(nbti.hasKey("HEALTH")) {
+                pm.getItemHealth().remove(player, nbti.getInteger("HEALTH"));
+
+            }
+            if(nbti.hasKey("DEFENSE")) {
+                pm.getItemDefense().remove(player, nbti.getInteger("DEFENSE"));
+
+            }
+            if(nbti.hasKey("STRENGTH")) {
+                pm.getItemStrength().remove(player, nbti.getInteger("STRENGTH"));
+
+            }
+        }
+        if(newItem != null && newItem.getType() != Material.AIR) {
+            NBTItem nbti = new NBTItem(newItem);
+            if(nbti.hasKey("SPEED")) {
+                pm.getItemSpeed().add(player, nbti.getInteger("SPEED"));
+            }
+            if(nbti.hasKey("HEALTH")) {
+                pm.getItemHealth().add(player, nbti.getInteger("HEALTH"));
+
+            }
+            if(nbti.hasKey("DEFENSE")) {
+                pm.getItemDefense().add(player, nbti.getInteger("DEFENSE"));
+
+            }
+            if(nbti.hasKey("STRENGTH")) {
+                pm.getItemStrength().add(player, nbti.getInteger("STRENGTH"));
+
+            }
+        }
+        PlayerUtils.updateSkills(main, player);
+    }
+}

src/main/java/me/unurled/raxen/listener/player/JoinEvent.java

@@ -0,0 +1,43 @@
+package me.unurled.raxen.listener.player;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.player.Scoreboard;
+import me.unurled.raxen.components.resourcepack.ResourcePack;
+import me.unurled.raxen.config.PlayerConfig;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public class JoinEvent implements Listener {
+
+    private Raxen main;
+    private PlayerConfig playerConfig;
+    private Scoreboard scoreboard;
+    private ResourcePack resourcePack;
+    private PlayerManager playerManager;
+
+    public JoinEvent(Raxen main) {
+        this.main = main;
+        this.playerConfig = main.getPlayerConfig();
+        this.scoreboard = new Scoreboard(main);
+        this.resourcePack = main.getManager().getResourcePackManager().getResourcePack();
+        this.playerManager = main.getManager().getPlayerManager();
+    }
+
+    /**
+     * when player joins, load from config all stats
+     * @param e
+     */
+    @EventHandler
+    public void PlayerJoinEvent(PlayerJoinEvent e) {
+        Player player = e.getPlayer();
+        playerConfig.loadPlayerConfig(player);
+        scoreboard.createScorebord(player);
+        resourcePack.join(player);
+        playerManager.getRaxenPlayer(player).isRaxenPlayer(true);
+        playerManager.registerActionBar(player);
+    }
+
+}

src/main/java/me/unurled/raxen/listener/player/LeaveEvent.java

@@ -0,0 +1,36 @@
+package me.unurled.raxen.listener.player;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.config.PlayerConfig;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import java.io.IOException;
+
+public class LeaveEvent implements Listener {
+
+    private final PlayerConfig playerConfig;
+    private PlayerManager playerManager;
+
+    public LeaveEvent(Raxen main) {
+        this.playerConfig = main.getPlayerConfig();
+        this.playerManager = main.getManager().getPlayerManager();
+
+    }
+
+    /**
+     * when player leaves, saves everything
+     * @param e
+     * @throws IOException
+     */
+    @EventHandler
+    public void PlayerLeaveEvent(PlayerQuitEvent e) throws IOException {
+        Player player = e.getPlayer();
+        playerConfig.savePlayerConfig(player);
+        playerManager.getRaxenPlayer(player).isRaxenPlayer(false);
+        playerManager.unRegisterActionBar(player);
+    }
+}

src/main/java/me/unurled/raxen/listener/player/PortalEvent.java

@@ -0,0 +1,27 @@
+package me.unurled.raxen.listener.player;
+
+import me.unurled.raxen.components.dungeons.Gate;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityPortalEnterEvent;
+
+import static me.unurled.raxen.utils.DungeonUtils.isInRange;
+import static me.unurled.raxen.utils.DungeonUtils.whichIsInRange;
+
+public class PortalEvent implements Listener {
+
+    @EventHandler
+    public void PortalE(EntityPortalEnterEvent e) {
+        if (e.getEntity() instanceof Player) {
+            Player p = (Player) e.getEntity();
+            Location loc = e.getLocation();
+            // if loc is in range
+            if (isInRange(loc)) {
+                Gate g = whichIsInRange(loc);
+                //g.t
+            }
+        }
+    }
+}

src/main/java/me/unurled/raxen/listener/player/ServerPingEvent.java

@@ -0,0 +1,40 @@
+package me.unurled.raxen.listener.player;
+
+import lombok.Getter;
+import lombok.Setter;
+import me.unurled.raxen.Raxen;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.server.ServerListPingEvent;
+
+import static me.unurled.raxen.utils.Utils.colorTextComp;
+
+public class ServerPingEvent implements Listener {
+
+    private Raxen main;
+    @Getter
+    @Setter
+    private boolean loading = false;
+
+    public ServerPingEvent(Raxen main) {
+        this.main = main;
+        this.loading = true;
+    }
+
+    /**
+     * set the motd
+     * @param e
+     */
+    @EventHandler
+    public void ServerListPingEvent(ServerListPingEvent e) {
+        FileConfiguration config = this.main.getConfig();
+        String motd = config.getString("motd");
+        String motdReload = config.getString("motd-reload");
+        if (loading) {
+            e.motd(colorTextComp(motdReload));
+        } else {
+            e.motd(colorTextComp(motd));
+        }
+    }
+}

src/main/java/me/unurled/raxen/listener/player/TransactionEvent.java

@@ -0,0 +1,34 @@
+package me.unurled.raxen.listener.player;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.player.Scoreboard;
+import me.unurled.raxen.utils.libs.Vault;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+
+public class TransactionEvent implements Listener {
+
+    private Raxen main;
+    private Scoreboard scoreboard;
+    private Vault vault;
+
+    public TransactionEvent(Raxen main) {
+        this.main = main;
+        this.scoreboard = new Scoreboard(main);
+        this.vault = main.getManager().getLibsManager().getVault();
+    }
+
+    /**
+     * set scoreboard when money changes
+     * @param e
+     */
+    @EventHandler
+    public void transaction(net.essentialsx.api.v2.events.TransactionEvent e) {
+        Player player = Bukkit.getPlayer(e.getTarget().getName());
+        Player source  = e.getRequester().getPlayer();
+        scoreboard.updateScoreboardTransaction(player);
+        scoreboard.updateScoreboardTransaction(source);
+    }
+}

src/main/java/me/unurled/raxen/manager/Manager.java

@@ -0,0 +1,59 @@
+package me.unurled.raxen.manager;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.manager.entity.*;
+import me.unurled.raxen.manager.server.*;
+import me.unurled.raxen.utils.libs.Multiverse;
+
+/**
+ * Manager class, it enables all features of the plugin.
+ * From commands, to Item and worlds, it links all of them together.
+ */
+public class Manager {
+
+    @Getter
+    private WorldManager worldManager;
+    @Getter
+    private StorageManager storageManager;
+    @Getter
+    private PlayerManager playerManager;
+    @Getter
+    private ListenerManager listenerManager;
+    @Getter
+    private CommandManager commandManager;
+    @Getter
+    private ItemManager itemManager;
+    @Getter
+    private ResourcePackManager resourcePackManager;
+    @Getter
+    private EntityManager entityManager;
+    @Getter
+    private LootManager lootManager;
+    @Getter
+    private LibsManager libsManager;
+    @Getter private DungeonsManager dungeonsManager;
+
+    @Getter private Multiverse multiverse;
+
+    /**
+     * Create an instance of all managers.
+     * @param main Raxen
+     */
+    public void set(Raxen main) {
+        libsManager = new LibsManager(main);
+        multiverse = new Multiverse();
+
+        worldManager = new WorldManager(main);
+        storageManager = new StorageManager(main);
+
+        itemManager = new ItemManager(main);
+        playerManager = new PlayerManager(main);
+        listenerManager = new ListenerManager(main);
+        commandManager = new CommandManager(main);
+        resourcePackManager = new ResourcePackManager(main);
+        entityManager = new EntityManager(main);
+        lootManager = new LootManager(main);
+        dungeonsManager = new DungeonsManager(main);
+    }
+}

src/main/java/me/unurled/raxen/manager/entity/EntityManager.java

@@ -0,0 +1,50 @@
+package me.unurled.raxen.manager.entity;
+
+import lombok.Getter;
+import lombok.Setter;
+import me.unurled.raxen.Raxen;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.UUID;
+
+import static me.unurled.raxen.utils.Utils.debug;
+
+public class EntityManager {
+
+    private Raxen main;
+
+    @Getter
+    @Setter
+    public List<EntityType> list = new ArrayList<>();
+
+    public HashMap<String, me.unurled.raxen.components.entity.other.custom.Entity> entities = new HashMap<>();
+
+    public HashMap<UUID, Entity> livingEntities = new HashMap<>();
+
+    public EntityManager(Raxen main) {
+        this.main = main;
+    }
+
+    public void registerLivingEntities(World world) {
+
+    }
+
+    /**
+     * used to register entities using fileconfigs but rapidly abandoned
+     * @param file
+     */
+    @Deprecated
+    public void registerEntityFromConfig(FileConfiguration file) {
+        debug(file.getString("id"));
+        World world = Bukkit.getWorld(file.getString("world"));
+        String name = file.getString("name");
+    }
+
+}

src/main/java/me/unurled/raxen/manager/entity/ItemManager.java

@@ -0,0 +1,123 @@
+package me.unurled.raxen.manager.entity;
+
+import de.tr7zw.nbtapi.NBTItem;
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.items.NBT;
+import me.unurled.raxen.components.items.custom.Item;
+import me.unurled.raxen.utils.Utils;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import static me.unurled.raxen.utils.Utils.*;
+
+public class ItemManager {
+
+    private final Raxen main;
+    @Getter
+    private HashMap<String, ItemStack> list = new HashMap<>();
+    private NBT nbt = new NBT();
+
+    public ItemManager(Raxen main) {
+        this.main = main;
+        // register();
+        registerItem();
+    }
+
+    /**
+     * register manually all item in Raxen
+     */
+    private void registerItem() {
+        me.unurled.raxen.components.items.custom.List lisst = new me.unurled.raxen.components.items.custom.List(main);
+        for (Item items : lisst.getItems()) {
+            items.registerItem(main);
+        }
+    }
+
+    /**
+     * Old system to register all items in the /items/ folder
+     */
+    @Deprecated
+    private void register() {
+        File folder = new File(main.getDataFolder() + "/Items/");
+        File[] listFile = folder.listFiles();
+
+        for (int i = 0; i < listFile.length; i++) {
+            if (listFile[i].isFile()) {
+                FileConfiguration customItem = new YamlConfiguration();
+                try {
+                    customItem.load(listFile[i]);
+                } catch (IOException | InvalidConfigurationException e) {
+                    e.printStackTrace();
+                }
+                registerItem(customItem);
+            } else if (listFile[i].isDirectory()) {
+                for (int a = 0; a < listFile[i].listFiles().length; a++) {
+                    if(listFile[i].listFiles()[a].isFile()) {
+                        FileConfiguration customItem = new YamlConfiguration();
+                        try {
+                            customItem.load(listFile[i].listFiles()[a]);
+                        } catch (IOException | InvalidConfigurationException e) {
+                            e.printStackTrace();
+                        }
+                        registerItem(customItem);
+                    } else if (listFile[i].listFiles()[a].isDirectory()) {
+                        error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),"Can't use more than 2 folder to get Items.yml");
+                    }
+
+                }
+            }
+        }
+    }
+
+    /**
+     * Old system to register for a file config an item inside.
+     * @param file
+     */
+    @Deprecated
+    private void registerItem(@NotNull FileConfiguration file) {
+        debug(main, file.getString("id"));
+        ItemStack it = new ItemStack(Objects.requireNonNull(Material.getMaterial((String) Objects.requireNonNull(file.get("id")))));
+        ItemMeta itm = it.getItemMeta();
+        itm.displayName(colorTextComp((String) file.get("name")));
+        List<Component> lore = ((List<String>) Objects.requireNonNull(file.get("lore"))).stream().map(Utils::colorTextComp).collect(Collectors.toList());
+        itm.setCustomModelData(Objects.requireNonNull(file.getConfigurationSection("Pack")).getInt("custom_model_data"));
+        itm.lore(lore);
+        it.setItemMeta(itm);
+        NBTItem nbti = new NBTItem(it);
+        nbti.setInteger(NBT.SPEED, file.getInt("speed"));
+        nbti.setInteger(NBT.HEALTH, file.getInt("health"));
+        nbti.setInteger(NBT.DEFENSE, file.getInt("defense"));
+        nbti.setInteger(NBT.STRENGTH, file.getInt("strength"));
+        nbti.setString(NBT.ID, file.getString("customId"));
+        nbti.setString(NBT.CUSTOM_ABILITY, file.getString("custom_ability"));
+        nbti.setDouble(NBT.DROP_RATE, file.getDouble("drop_rate"));
+        it = nbti.getItem();
+        //it = setLoreFromNBT(it); deprecated
+        list.put(file.getString("customId"), it);
+    }
+
+    /**
+     * register Item into the custom item list
+     * Need that the Itm is already set with custom nbt!
+     * @param itm an ItemStack with already set custom nbt using NBTapi
+     */
+    public void registerItem(ItemStack itm) {
+        NBTItem it = new NBTItem(itm);
+        list.put(it.getString("ID"), itm);
+    }
+}

src/main/java/me/unurled/raxen/manager/entity/LootManager.java

@@ -0,0 +1,20 @@
+package me.unurled.raxen.manager.entity;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.lootchest.loots.LootItem;
+
+import java.util.List;
+
+public class LootManager {
+
+    private Raxen main;
+    @Getter
+    private List<LootItem> lootTable;
+
+
+    public LootManager(Raxen main) {
+        this.main = main;
+    }
+
+}

src/main/java/me/unurled/raxen/manager/entity/PlayerManager.java

@@ -0,0 +1,209 @@
+package me.unurled.raxen.manager.entity;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.Attributes.*;
+import me.unurled.raxen.components.entity.other.EntityNamespacedKey;
+import me.unurled.raxen.components.entity.player.RaxenPlayer;
+import me.unurled.raxen.components.entity.player.classes.Class;
+import net.kyori.adventure.text.Component;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.HashMap;
+import java.util.UUID;
+
+public class PlayerManager {
+
+    private Raxen main;
+    private HashMap<UUID, BukkitTask> actionBar = new HashMap<>();
+    private HashMap<String, Class> classes = new HashMap<>();
+    @Getter
+    private HashMap<String, me.unurled.raxen.components.entity.Attributes.Attribute> attribute = new HashMap<>();
+
+    // Attributes
+    private Defense defense;
+    private Health health;
+    private ItemDefense itemDefense;
+    private ItemHealth itemHealth;
+    private ItemLuck itemLuck;
+    private ItemMana itemMana;
+    private ItemSpeed itemSpeed;
+    private ItemStrength itemStrength;
+    private Luck luck;
+    private Mana mana;
+    private MaxHealth maxHealth;
+    private MaxMana maxMana;
+    private Speed speed;
+    private Strength strength;
+
+    public PlayerManager(Raxen main) {
+        this.main = main;
+        registerAttributes();
+    }
+
+    public RaxenPlayer getRaxenPlayer(Player player) {
+        return new RaxenPlayer(main, player);
+    }
+
+    /**
+     * add a task to the player action bar.
+     * @param player
+     */
+    public void registerActionBar(Player player) {
+        PlayerManager pm = main.getManager().getPlayerManager();
+         BukkitTask task = new BukkitRunnable() {
+            @Override
+            public void run() {
+                player.sendActionBar(Component.text(pm.getHealth().get(player) + "/" + pm.getMaxHealth().get(player) + "❤  " + pm.getMana().get(player) + "/" + pm.getMaxMana().get(player)));
+            }
+        }.runTaskTimer(main, 0L, 20L);
+         if(actionBar.containsKey(player.getUniqueId())) {
+             actionBar.replace(player.getUniqueId(), task);
+         } else {
+             actionBar.put(player.getUniqueId(), task);
+         }
+    }
+
+    /**
+     * removes the task of action bar to player
+     * @param player
+     */
+    public void unRegisterActionBar(Player player) {
+        if(actionBar.containsKey(player.getUniqueId())) {
+            BukkitTask task = actionBar.get(player.getUniqueId());
+            task.cancel();
+            actionBar.remove(player.getUniqueId());
+        }
+    }
+
+    public void unRegisterRaxenPlayer(Player player) {
+    }
+
+    public void registerClasses() {
+
+    }
+
+    /**
+     * getClasses
+     * @return the classes HashMap
+     */
+    public HashMap<String, Class> getClasses() {
+        return classes;
+    }
+
+    /**
+     * add @param to hashmap of classes
+     * @param clas a class instance
+     * @param id the id of the class
+     */
+    public void addClasses(Class clas, String id) {
+        classes.put(id, clas);
+    }
+
+    /**
+     * register all Attributes in me.unurled.raxen.components.entity.Attributes;
+      */
+    public void registerAttributes() {
+        EntityNamespacedKey key = new EntityNamespacedKey(main);
+
+        this.defense = new Defense(key.defense, "DEFENSE");
+        attribute.put("DEFENSE", defense);
+
+        this.health = new Health(key.health, "HEALTH");
+        attribute.put("HEALTH", health);
+
+        this.itemDefense = new ItemDefense(key.itemDefense, "ITEM_DEFENSE");
+        attribute.put("ITEM_DEFENSE", itemDefense);
+
+        this.itemHealth = new ItemHealth(key.itemHealth, "ITEM_HEALTH");
+        attribute.put("ITEM_HEALTH", itemHealth);
+
+        this.itemLuck = new ItemLuck(key.itemLuck, "ITEM_LUCK");
+        attribute.put("ITEM_LUCK", itemLuck);
+
+        this.itemMana = new ItemMana(key.itemMana, "ITEM_MANA");
+        attribute.put("ITEM_MANA", itemMana);
+
+        this.itemSpeed = new ItemSpeed(key.itemSpeed, "ITEM_SPEED");
+        attribute.put("ITEM_SPEED", itemSpeed);
+
+        this.itemStrength = new ItemStrength(key.itemStrength, "ITEM_STRENGTH");
+        attribute.put("ITEM_STRENGTH", itemStrength);
+
+        this.luck = new Luck(key.luck, "LUCK");
+        attribute.put("LUCK", luck);
+
+        this.mana = new Mana(key.mana, "MANA");
+        attribute.put("MANA", mana);
+
+        this.maxMana = new MaxManaBuilder().setNamespacekey(key.maxMana).setName("MAX_MANA").createMaxMana();
+        attribute.put("MAX_MANA", maxMana);
+
+        this.maxHealth = new MaxHealth(key.maxHealth, "MAX_HEALTH");
+        attribute.put("MAX_HEALTH", maxHealth);
+
+        this.speed = new Speed(key.speed, "SPEED");
+        attribute.put("SPEED", speed);
+
+        this.strength = new Strength(key.strength, "STRENGTH");
+        attribute.put("STRENGTH", strength);
+    }
+
+    public Defense getDefense() {
+        return (Defense) attribute.get("DEFENSE");
+    }
+
+    public Health getHealth() {
+        return (Health) attribute.get("HEALTH");
+    }
+
+    public ItemDefense getItemDefense() {
+        return (ItemDefense) attribute.get("ITEM_DEFENSE");
+    }
+
+    public ItemHealth getItemHealth() {
+        return (ItemHealth) attribute.get("ITEM_HEALTH");
+    }
+
+    public ItemLuck getItemLuck() {
+        return (ItemLuck) attribute.get("ITEM_LUCK");
+    }
+
+    public ItemMana getItemMana() {
+        return (ItemMana) attribute.get("ITEM_MANA");
+    }
+
+    public ItemSpeed getItemSpeed() {
+        return (ItemSpeed) attribute.get("ITEM_SPEED");
+    }
+
+    public ItemStrength getItemStrength() {
+        return (ItemStrength) attribute.get("ITEM_STRENGTH");
+    }
+
+    public Luck getLuck() {
+        return (Luck) attribute.get("LUCK");
+    }
+
+    public Mana getMana() {
+        return (Mana) attribute.get("MANA");
+    }
+
+    public MaxMana getMaxMana() {
+        return (MaxMana) attribute.get("MAX_MANA");
+    }
+
+    public MaxHealth getMaxHealth() {
+        return (MaxHealth) attribute.get("MAX_HEALTH");
+    }
+
+    public Speed getSpeed() {
+        return (Speed) attribute.get("SPEED");
+    }
+
+    public Strength getStrength() {
+        return (Strength) attribute.get("STRENGTH");
+    }
+}

src/main/java/me/unurled/raxen/manager/entity/StorageManager.java

@@ -0,0 +1,166 @@
+package me.unurled.raxen.manager.entity;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.utils.libs.MongoDB;
+import me.unurled.raxen.utils.libs.Mysql;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.File;
+import java.io.IOException;
+
+import static me.unurled.raxen.utils.Utils.debug;
+import static me.unurled.raxen.utils.Utils.error;
+
+public class StorageManager {
+
+    private static Raxen main;
+    @Getter
+    private static FileConfiguration config;
+
+    @Getter
+    private static MongoDB mongodb;
+    @Getter
+    private static Mysql mysql;
+
+    public StorageManager(Raxen main) {
+        this.main = main;
+        this.config = main.getConfig();
+        this.connect();
+    }
+
+    /**
+     * Connects to the storage system (MONGO, YML, MYSQL (not implemented))
+     */
+    public static void connect() {
+        String s = (String) config.get("storage");
+        debug(main, s);
+        mongodb = main.getManager().getLibsManager().getMongoDB();
+        if(s.equalsIgnoreCase("MONGODB")) {
+            mongodb.connect();
+            debug(main, "'" + s + "'");
+        } else if(s.equalsIgnoreCase("MYSQL")) {
+            error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),"Currently not implemented, switching to YML");
+            debug(main, "'" + s + "'");
+        } else {
+            debug(main, "'" + s + "'");
+        }
+    }
+
+    /**
+     * disconnect mysql db
+     */
+    public static void disconnect() {
+        mysql.disconnect();
+    }
+
+    /**
+     * create a new yml for the player
+     * @param player
+     * @return the created yml
+     */
+    public static @NotNull FileConfiguration createYml(@NotNull Player player) {
+        File customFile;
+        FileConfiguration customConfig;
+        customFile = new File(main.getDataFolder() + "/playerInfo/" + player.getUniqueId(), "/playerInfo.yml");
+
+        if (!customFile.exists()) {
+            customFile.getParentFile().mkdirs();
+            try {
+                customFile.createNewFile();
+            }
+            catch (IOException e) {
+                error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),"Error in Storage Manager saving new File.");
+                e.printStackTrace();
+            }
+        }
+
+        customConfig = new YamlConfiguration();
+        try {
+            customConfig.load(customFile);
+        } catch (IOException | InvalidConfigurationException e) {
+            e.printStackTrace();
+        }
+        if (customConfig.get("uuid") == null) {
+            customConfig.set("uuid", player.getUniqueId().toString());
+            customConfig.set("name", player.getName());
+            customConfig.set("health", 100);
+            customConfig.set("itemHealth", 0);
+            customConfig.set("defense", 50);
+            customConfig.set("itemDefense", 0);
+            customConfig.set("speed", 100);
+            customConfig.set("itemSpeed", 0);
+            customConfig.set("strength", 100);
+            customConfig.set("itemDmg", 0);
+            customConfig.set("inv","");
+            customConfig.set("ec","");
+            try {
+                customConfig.save(customFile);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return customConfig;
+    }
+
+    /**
+     * create a config yaml with the file
+     * @param file
+     * @return a file configuration
+     */
+    public static @NotNull FileConfiguration createYml(@NotNull File file) {
+
+        FileConfiguration customConfig;
+
+        if (!file.exists()) {
+            file.getParentFile().mkdirs();
+            try {
+                file.createNewFile();
+            }
+            catch (IOException e) {
+                error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),"Error in Storage Manager saving new File.");
+                e.printStackTrace();
+            }
+        }
+        customConfig = new YamlConfiguration();
+        try {
+            customConfig.load(file);
+        } catch (IOException | InvalidConfigurationException e) {
+            e.printStackTrace();
+        }
+        return customConfig;
+    }
+
+    /**
+     * create a config in the path provided
+     * @param path
+     * @return the created config file
+     */
+    public static @NotNull FileConfiguration createYml(String path) {
+        File customFile;
+        FileConfiguration customConfig;
+        customFile = new File(path);
+        if (!customFile.exists()) {
+            customFile.getParentFile().mkdirs();
+            try {
+                customFile.createNewFile();
+            }
+            catch (IOException e) {
+                error((Raxen) Bukkit.getPluginManager().getPlugin("Raxen"),"Error in Storage Manager saving new File.");
+                e.printStackTrace();
+            }
+        }
+        customConfig = new YamlConfiguration();
+        try {
+            customConfig.load(customFile);
+        } catch (IOException | InvalidConfigurationException e) {
+            e.printStackTrace();
+        }
+        return customConfig;
+    }
+}

src/main/java/me/unurled/raxen/manager/server/CommandManager.java

@@ -0,0 +1,80 @@
+package me.unurled.raxen.manager.server;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.commands.RaxenCommand;
+import me.unurled.raxen.commands.admin.*;
+import me.unurled.raxen.commands.player.ClassCommand;
+import me.unurled.raxen.commands.player.MainGuiCommand;
+import me.unurled.raxen.commands.player.SkillsCommand;
+import me.unurled.raxen.commands.player.StorageCommand;
+
+
+public class CommandManager {
+
+    private Raxen main;
+    @Getter
+    private ItemListCommand itemListCommand;
+    private ReloadCommand reloadComand = new ReloadCommand();
+    private NbtCommand nbtCommand;
+    private TestGuiCommand testGuiCommand = new TestGuiCommand();
+    private StorageCommand storageCommand = new StorageCommand();
+    private SkillsCommand skillsCommand;
+    private RaxenCommand raxenCommand;
+    private SpawnEntity entityspawn;
+    private ClassCommand classCommand;
+    private  CustomModelDataCommand customModelDataCommand;
+    private MainGuiCommand mainGuiCommand;
+
+    public CommandManager(Raxen main) {
+        this.main = main;
+        this.itemListCommand = new ItemListCommand(this.main);
+        this.nbtCommand = new NbtCommand(this.main);
+        this.entityspawn = new SpawnEntity(this.main);
+        this.classCommand = new ClassCommand(this.main);
+        this.skillsCommand = new SkillsCommand(main);
+        this.raxenCommand = new RaxenCommand(main);
+        this.customModelDataCommand = new CustomModelDataCommand();
+        this.mainGuiCommand = new MainGuiCommand(main);
+    }
+
+    /**
+     * register/add all the plugin's command
+     */
+    public void register() {
+        main.getCommand("reloadplugin").setExecutor(reloadComand);
+        main.getCommand("reloadplugin").setTabCompleter(reloadComand);
+
+        main.getCommand("nbt").setExecutor(nbtCommand);
+        main.getCommand("nbt").setTabCompleter(nbtCommand);
+
+        main.getCommand("testgui").setExecutor(testGuiCommand);
+        main.getCommand("testgui").setTabCompleter(testGuiCommand);
+
+        main.getCommand("storage").setExecutor(storageCommand);
+        main.getCommand("storage").setTabCompleter(storageCommand);
+
+
+        main.getCommand("skills").setTabCompleter(skillsCommand);
+        main.getCommand("skills").setExecutor(skillsCommand);
+
+        main.getCommand("raxen").setTabCompleter(raxenCommand);
+        main.getCommand("raxen").setExecutor(raxenCommand);
+
+        main.getCommand("itemlist").setExecutor(itemListCommand);
+        main.getCommand("itemlist").setTabCompleter(itemListCommand);
+
+        main.getCommand("entityspawn").setTabCompleter(entityspawn);
+        main.getCommand("entityspawn").setExecutor(entityspawn);
+
+        main.getCommand("class").setTabCompleter(classCommand);
+        main.getCommand("class").setExecutor(classCommand);
+
+        main.getCommand("custommodeldata").setTabCompleter(customModelDataCommand);
+        main.getCommand("custommodeldata").setExecutor(customModelDataCommand);
+
+        main.getCommand("main_gui").setTabCompleter(mainGuiCommand);
+        main.getCommand("main_gui").setExecutor(mainGuiCommand);
+    }
+
+}

src/main/java/me/unurled/raxen/manager/server/DungeonsManager.java

@@ -0,0 +1,41 @@
+package me.unurled.raxen.manager.server;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.dungeons.Dungeon;
+import me.unurled.raxen.components.dungeons.Gate;
+import me.unurled.raxen.components.dungeons.types.forest.ForestDungeon;
+import org.bukkit.Location;
+
+import java.util.HashMap;
+
+public class DungeonsManager {
+
+    private Raxen main;
+
+    private HashMap<Gate, Location> gates = new HashMap<>();
+
+    private HashMap<Gate, Dungeon> dungeons = new HashMap<>();
+
+    public DungeonsManager(Raxen main) {
+        this.main = main;
+        registerDungeons();
+    }
+
+    /**
+     * register/add all made dungeon to the available plugin list
+     */
+    public void registerDungeons() {
+        ForestDungeon forestDungeon = new ForestDungeon();
+        dungeons.put(forestDungeon.getGate(), forestDungeon);
+        gates.put(forestDungeon.getGate(), forestDungeon.getGate().getLoc());
+        /*
+        for (String s : dungeons.keySet()) {
+            main.getManager().getWorldManager().loadWorld(dungeons.get(s).getName());
+        }
+         */
+    }
+
+    public HashMap getGates() {
+        return gates;
+    }
+}

src/main/java/me/unurled/raxen/manager/server/EnchantmentManager.java

@@ -0,0 +1,21 @@
+package me.unurled.raxen.manager.server;
+
+import org.bukkit.enchantments.Enchantment;
+
+import java.lang.reflect.Field;
+
+public class EnchantmentManager {
+
+    public static void registerEnchantment(Enchantment enchantment) {
+        boolean registered = true;
+        try {
+            Field f = Enchantment.class.getDeclaredField("acceptingNew");
+            f.setAccessible(true);
+            f.set(null, true);
+            Enchantment.registerEnchantment(enchantment);
+        } catch (Exception e) {
+            registered = false;
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/me/unurled/raxen/manager/server/LibsManager.java

@@ -0,0 +1,32 @@
+package me.unurled.raxen.manager.server;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.utils.libs.*;
+
+public class LibsManager {
+    @Getter
+    private final ProtocolManager protocolManager;
+    @Getter
+    private final LuckPerm luckPerm;
+    @Getter
+    private final Vault vault;
+    @Getter
+    private final MongoDB mongoDB;
+    @Getter
+    private static Mysql mysql;
+    @Getter
+    private PlaceHolderAPI placeHolderAPI;
+    @Getter
+    private Citizens citizens;
+
+    public LibsManager(Raxen main) {
+        this.luckPerm = new LuckPerm(main);
+        this.luckPerm.register();
+        this.vault = new Vault(main);
+        this.protocolManager = new ProtocolManager(main);
+        this.mongoDB = new MongoDB();
+        this.placeHolderAPI = new PlaceHolderAPI(main);
+        this.citizens = new Citizens(main);
+    }
+}

src/main/java/me/unurled/raxen/manager/server/ListenerManager.java

@@ -0,0 +1,42 @@
+package me.unurled.raxen.manager.server;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.listener.entity.DamageEntity;
+import me.unurled.raxen.listener.entity.SpawnEvent;
+import me.unurled.raxen.listener.player.*;
+import me.unurled.raxen.utils.Reload;
+import org.bukkit.plugin.PluginManager;
+
+public class ListenerManager {
+
+    private final Raxen main;
+    private final PluginManager pm;
+    @Getter
+    private ServerPingEvent serverPingEvent;
+
+    public ListenerManager(Raxen main) {
+        this.main = main;
+        this.pm = main.getPm();
+        this.serverPingEvent = new ServerPingEvent(main);
+    }
+
+    /**
+     * register/addd listener events
+     */
+    public void register() {
+        this.pm.registerEvents(new JoinEvent(main), main);
+        this.pm.registerEvents(new LeaveEvent(main), main);
+        this.pm.registerEvents(new ArmorEvent(main), main);
+        this.pm.registerEvents(new ItemHandEvent(main), main);
+        this.pm.registerEvents(new Reload(), main);
+        this.pm.registerEvents(new TransactionEvent(main), main);
+        this.pm.registerEvents(main.getManager().getCommandManager().getItemListCommand().getItemListGui(), main);
+        this.pm.registerEvents(new DamageEntity(main), main);
+        this.pm.registerEvents(new SpawnEvent(main), main);
+        this.pm.registerEvents(new ClickBlockEvent(main), main);
+        this.pm.registerEvents(serverPingEvent, main);
+        this.pm.registerEvents(new CloseInventoryEvent(), main);
+
+    }
+}

src/main/java/me/unurled/raxen/manager/server/ProtocolManager.java

@@ -0,0 +1,31 @@
+package me.unurled.raxen.manager.server;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.ListenerPriority;
+import com.comphenix.protocol.events.PacketAdapter;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.events.PacketEvent;
+import me.unurled.raxen.Raxen;
+import org.bukkit.entity.Player;
+
+public class ProtocolManager {
+
+    private final Raxen main;
+    private com.comphenix.protocol.ProtocolManager manager;
+
+    public ProtocolManager(Raxen main) {
+        this.main = main;
+        this.manager = main.getProtocolManager();
+    }
+
+    public void listen() {
+        manager.addPacketListener(new PacketAdapter(main, ListenerPriority.NORMAL, PacketType.Play.Client.BLOCK_DIG) {
+            @Override
+            public void onPacketReceiving(PacketEvent event) {
+                Player player = event.getPlayer();
+                PacketContainer packet = event.getPacket();
+                // if(player.)
+            }
+        });
+    }
+}

src/main/java/me/unurled/raxen/manager/server/ResourcePackManager.java

@@ -0,0 +1,49 @@
+package me.unurled.raxen.manager.server;
+
+import lombok.Getter;
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.resourcepack.ResourcePack;
+import org.bukkit.configuration.file.FileConfiguration;
+
+import java.util.Objects;
+
+import static me.unurled.raxen.utils.Utils.debug;
+import static me.unurled.raxen.utils.Utils.error;
+
+public class ResourcePackManager {
+
+    private Raxen main;
+    @Getter
+    private ResourcePack resourcePack;
+    private FileConfiguration config;
+    @Getter
+    private boolean useRP;
+
+    public ResourcePackManager(Raxen main) {
+        this.main = main;
+        this.resourcePack = new ResourcePack(main, this);
+        this.config = main.getConfig();
+        this.useRP = this.config.getBoolean("useResourcePack");
+        enable();
+    }
+
+    /**
+     * Method to enable the ressourcpack
+     */
+    private void enable() {
+        if(useRP) {
+            if(config.getString("resource_pack_url") == null || Objects.equals(config.getString("rssource_pack_url"), "") ||
+                    config.getString("resource_pack_sha1") == null || Objects.equals(config.getString("resource_pack_sha1"), "") ||
+                    Objects.equals(config.getString("resource_pack_url"), "https://mc-packs.net/") || Objects.equals(config.getString("resource_pack_sha1"), "sha1hallo")) {
+                error(main, "You must specify an resource_pack_url and resource_pack_sha1!");
+                debug(main, "Resource pack not enabled.");
+                useRP = false;
+            } else {
+                debug(main, "Ressource Pack enabled.");
+            }
+        } else {
+            debug(main, "Resource pack not enabled.");
+        }
+
+    }
+}

src/main/java/me/unurled/raxen/manager/server/WorldManager.java

@@ -0,0 +1,113 @@
+package me.unurled.raxen.manager.server;
+
+import com.onarandombox.MultiverseCore.api.MVWorldManager;
+import com.onarandombox.MultiverseCore.api.MultiverseWorld;
+import me.unurled.raxen.Raxen;
+import org.bukkit.World;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static me.unurled.raxen.utils.Utils.*;
+
+public class WorldManager {
+
+    private Raxen main;
+
+    MVWorldManager worldManager;
+
+    /**
+     * String : name
+     * MultiverseWorld : a world that need to be registered
+     */
+    private Map<String, MultiverseWorld> loadedWorlds = new HashMap<>();
+
+    private List<String> worlds = new ArrayList<>();
+
+    private File pluginFolder;
+    private File worldFolder;
+
+    public WorldManager(Raxen main) {
+        this.main = main;
+        this.pluginFolder = new File(main.getDataFolder() + "/worlds/");
+        this.worldFolder = new File("worlds/");
+        this.worldManager = main.getManager().getMultiverse().getWorldManager();
+        worlds.add("Forest");
+    }
+
+    /**
+     * remove a world
+     * @param name
+     */
+    public void removeWorld(String name) {
+        File world = new File(worldFolder + name + "/");
+        if (!world.exists() || !world.isDirectory()) {
+            error("Saving world " + name + ". Folder don't exists.");
+            return;
+        }
+        worldManager.unloadWorld(name);
+        try {
+            removeDirectory(world.toPath());
+        } catch (IOException e) {
+            error("Error while Saving world " + name + " at coping data.");
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * load all world in the worlds folder
+     */
+    public void load() {
+        if (!pluginFolder.exists()) {
+            pluginFolder.mkdirs();
+            error("Please put in the folder " + pluginFolder.getAbsolutePath() + " all the needed worlds :");
+            for (String s : worlds) {
+                error(" - " + s + ",");
+            }
+            return;
+        }
+        for (String s : worlds) {
+            File world = new File(pluginFolder + s);
+            File worldd = new File(worldFolder + s);
+            if (worldd.exists()) {
+                if (worldd.isDirectory()) {
+                    worldManager.loadWorld(s);
+                }
+            } else if (world.exists() ) {
+                if (world.isDirectory()) {
+                    loadWorld(s);
+                } else {
+                    error("World " + s + " is not a world Folder!");
+                }
+            } else {
+                error("World " + s + " do not exist.");
+            }
+        }
+    }
+
+    /**
+     * load world from the name of it
+     * @param name
+     */
+    public void loadWorld(String name) {
+        File world = new File(pluginFolder + "/" + name + "/");
+        if (!world.exists() || !world.isDirectory()) {
+            error("Loading world " + name + ". Folder " + world.getAbsolutePath() + " don't exists.");
+            return;
+        }
+        File newWorld = new File(worldFolder + "/" + name);
+        try {
+            log(colorTextComp("<aqua>Copping world " + world.getName() + ".</aqua>"), colorTextComp("<blue>From " + world.getAbsolutePath() + " to " + newWorld.getAbsolutePath() +".</blue>"));
+            copyDirectory(world.getAbsolutePath(), newWorld.getAbsolutePath());
+        } catch (IOException e) {
+            error("Error while Loading world " + name + " at coping data.");
+            e.printStackTrace();
+        }
+        worldManager.loadWorld(name);
+        worldManager.addWorld(world.getName(), World.Environment.NORMAL, null, null, false, null);
+    }
+}

src/main/java/me/unurled/raxen/utils/DungeonUtils.java

@@ -0,0 +1,103 @@
+package me.unurled.raxen.utils;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.dungeons.Gate;
+import me.unurled.raxen.components.dungeons.Rank;
+import me.unurled.raxen.components.dungeons.Types;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Random;
+
+public class DungeonUtils {
+
+    /**
+     * get the radius from the rank of a dungeon
+     */
+    public static Integer getRadiusFromRank(@NotNull Rank rank) {
+        Integer radius = 1;
+        switch (rank) {
+            case F:
+                radius = 4;
+            case E:
+                radius = 5;
+            case D:
+                radius = 8;
+            case C:
+                radius = 10;
+            case B:
+                radius = 15;
+            case A:
+                radius = 20;
+            case S:
+                radius = 30;
+            case SS:
+                radius = 40;
+            case SSS:
+                radius = 50;
+            case WORLD:
+                radius = 100;
+            case UNBEATABLE:
+                radius = 200;
+            case NOT_DEFINED:
+                radius = 1000;
+        }
+        return radius;
+    }
+
+    /**
+     * used to spawn monster based on random
+     */
+    public static void fromTypeToMonster(Types types, Rank rank) {
+        Random r = new Random();
+        r.nextInt();
+    }
+
+    /**
+     * if a gate is in range of the player
+     * @return boolean
+     */
+    public static Boolean isInRange(Location loc) {
+        Raxen main = (Raxen) Bukkit.getServer().getPluginManager().getPlugin("Raxen");
+        HashMap<Gate, Location> gats = main.getManager().getDungeonsManager().getGates();
+        for (Gate g : gats.keySet()) {
+            Double x = g.getLoc().getX();
+            Double y = g.getLoc().getY();
+            Double z = g.getLoc().getZ();
+            Double radius = Double.valueOf(g.getPortalRadius());
+            if (loc.getX() < x+radius && loc.getX() > x-radius) {
+                if (loc.getY() < y+radius && loc.getY() > y-radius) {
+                    if (loc.getZ() < z+radius && loc.getZ() > z-radius) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * if a gate is in range of the player
+     * @return the gates which is in range
+     */
+    public static Gate whichIsInRange(Location loc) {
+        Raxen main = (Raxen) Bukkit.getServer().getPluginManager().getPlugin("Raxen");
+        HashMap<Gate, Location> gats = main.getManager().getDungeonsManager().getGates();
+        for (Gate g : gats.keySet()) {
+            Double x = g.getLoc().getX();
+            Double y = g.getLoc().getY();
+            Double z = g.getLoc().getZ();
+            Double radius = Double.valueOf(g.getPortalRadius());
+            if (loc.getX() < x+radius && loc.getX() > x-radius) {
+                if (loc.getY() < y+radius && loc.getY() > y-radius) {
+                    if (loc.getZ() < z+radius && loc.getZ() > z-radius) {
+                        return g;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+}

src/main/java/me/unurled/raxen/utils/EntityAttributes.java

@@ -0,0 +1,65 @@
+package me.unurled.raxen.utils;
+
+import me.unurled.raxen.Raxen;
+import me.unurled.raxen.components.entity.player.attributes.Attribute;
+import me.unurled.raxen.manager.entity.PlayerManager;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Entity;
+
+import java.util.Objects;
+
+import static me.unurled.raxen.utils.Utils.debug;
+
+public class EntityAttributes {
+
+
+    /**
+     * get every attribute of an entity
+     * @param e an entity
+     * @return an instance of attribute
+     */
+    public static Attribute getAttribute(Entity e) {
+        int maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck;
+        PlayerManager pm = ((Raxen) Objects.requireNonNull(Bukkit.getPluginManager().getPlugin("Raxen"))).getManager().getPlayerManager();
+        defense= pm.getDefense().get(e);
+        maxMana = pm.getMaxMana().get(e);
+        itemDefense= pm.getItemDefense().get(e);
+        health = pm.getHealth().get(e);
+        itemHealth = pm.getItemHealth().get(e);
+        mana = pm.getMana().get(e);
+        speed = pm.getSpeed().get(e);
+        itemLuck = pm.getItemLuck().get(e);
+        strength = pm.getStrength().get(e);
+        luck = pm.getLuck().get(e);
+        maxHealth = pm.getMaxHealth().get(e);
+        itemStrength = pm.getItemStrength().get(e);
+        itemSpeed = pm.getItemSpeed().get(e);
+        itemMana = pm.getItemMana().get(e);
+        return new Attribute(maxHealth, health, itemHealth, defense, itemDefense, speed, itemSpeed, strength, itemStrength, maxMana, mana, itemMana, luck, itemLuck);
+    }
+
+    /**
+     * set each attribute
+     */
+    public static void setAttributes(Entity e, int maxHealth, int health, int itemHealth, int defense, int itemDefense, int speed, int itemSpeed, int strength, int itemStrength, int maxMana, int mana, int itemMana, int luck, int itemLuck) {
+        PlayerManager pm = ((Raxen) Objects.requireNonNull(Bukkit.getPluginManager().getPlugin("Raxen"))).getManager().getPlayerManager();
+        pm.getDefense().set(e, defense);
+        pm.getMaxMana().set(e, maxMana);
+        pm.getItemDefense().set(e, itemDefense);
+        pm.getHealth().set(e, health);
+        pm.getItemHealth().set(e, itemHealth);
+        pm.getMana().set(e, mana);
+        pm.getSpeed().set(e, speed);
+        pm.getItemLuck().set(e, itemLuck);
+        pm.getStrength().set(e, strength);
+        pm.getLuck().set(e, luck);
+        pm.getMaxHealth().set(e, maxHealth);
+        pm.getItemStrength().set(e, itemStrength);
+        pm.getItemSpeed().set(e, itemSpeed);
+        pm.getItemMana().set(e, itemMana);
+        debug("Speedometer " + speed);
+        for (String s : pm.getAttribute().keySet()) {
+            debug(s + " " + pm.getAttribute().get(s).get(e).toString());
+        }
+    }
+}